]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[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
1707
1708 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
1709 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
1710 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1711 bool found; \
1712 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1713 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1714 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
1715 Py_DECREF(obj); \
1716 } \
1717 wxPyEndBlockThreads(blocked); \
1718 if (! found) \
1719 PCLASS::CBNAME(attr, a, b); \
1720 }
1721
1722
1723
1724 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
1725 void CBNAME(wxGridCellAttr *attr, int val) { \
1726 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1727 bool found; \
1728 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1729 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1730 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
1731 Py_DECREF(obj); \
1732 } \
1733 wxPyEndBlockThreads(blocked); \
1734 if (! found) \
1735 PCLASS::CBNAME(attr, val); \
1736 }
1737
1738
1739
1740 #define PYCALLBACK_INT__pure(CBNAME) \
1741 int CBNAME() { \
1742 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1743 int rval = 0; \
1744 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1746 wxPyEndBlockThreads(blocked); \
1747 return rval; \
1748 }
1749
1750
1751
1752 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
1753 bool CBNAME(int a, int b) { \
1754 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1755 bool rval = 0; \
1756 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1757 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
1758 wxPyEndBlockThreads(blocked); \
1759 return rval; \
1760 }
1761
1762
1763 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
1764 wxString CBNAME(int a, int b) { \
1765 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1766 wxString rval; \
1767 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1768 PyObject* ro; \
1769 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1770 if (ro) { \
1771 rval = Py2wxString(ro); \
1772 Py_DECREF(ro); \
1773 } \
1774 } \
1775 wxPyEndBlockThreads(blocked); \
1776 return rval; \
1777 }
1778
1779
1780 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
1781 void CBNAME(int a, int b, const wxString& c) { \
1782 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1783 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1784 PyObject* s = wx2PyString(c); \
1785 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1786 Py_DECREF(s); \
1787 } \
1788 wxPyEndBlockThreads(blocked); \
1789 }
1790
1791
1792 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
1793 wxString CBNAME(int a, int b) { \
1794 bool found; \
1795 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1796 wxString rval; \
1797 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1798 PyObject* ro; \
1799 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1800 if (ro) { \
1801 rval = Py2wxString(ro); \
1802 Py_DECREF(ro); \
1803 } \
1804 } \
1805 wxPyEndBlockThreads(blocked); \
1806 if (! found) \
1807 rval = PCLASS::CBNAME(a, b); \
1808 return rval; \
1809 }
1810
1811
1812 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
1813 bool CBNAME(int a, int b, const wxString& c) { \
1814 bool rval = 0; \
1815 bool found; \
1816 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1817 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1818 PyObject* s = wx2PyString(c); \
1819 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1820 Py_DECREF(s); \
1821 } \
1822 wxPyEndBlockThreads(blocked); \
1823 if (! found) \
1824 rval = PCLASS::CBNAME(a,b,c); \
1825 return rval; \
1826 }
1827
1828
1829
1830
1831 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
1832 long CBNAME(int a, int b) { \
1833 long rval; \
1834 bool found; \
1835 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1836 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1837 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1838 wxPyEndBlockThreads(blocked); \
1839 if (! found) \
1840 rval = PCLASS::CBNAME(a,b); \
1841 return rval; \
1842 }
1843
1844
1845 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
1846 bool CBNAME(int a, int b) { \
1847 bool rval = 0; \
1848 bool found; \
1849 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1850 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1851 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1852 wxPyEndBlockThreads(blocked); \
1853 if (! found) \
1854 rval = PCLASS::CBNAME(a,b); \
1855 return rval; \
1856 }
1857
1858
1859
1860 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
1861 double CBNAME(int a, int b) { \
1862 bool found; \
1863 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1864 double rval; \
1865 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1866 PyObject* ro; \
1867 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1868 if (ro) { \
1869 PyObject* str = PyObject_Str(ro); \
1870 rval = PyFloat_AsDouble(str); \
1871 Py_DECREF(ro); Py_DECREF(str); \
1872 } \
1873 } \
1874 wxPyEndBlockThreads(blocked); \
1875 if (! found) \
1876 rval = PCLASS::CBNAME(a, b); \
1877 return rval; \
1878 }
1879
1880
1881
1882 #define PYCALLBACK__(PCLASS, CBNAME) \
1883 void CBNAME() { \
1884 bool found; \
1885 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1886 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1887 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1888 wxPyEndBlockThreads(blocked); \
1889 if (! found) \
1890 PCLASS::CBNAME(); \
1891 }
1892
1893
1894
1895 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
1896 bool CBNAME(size_t a, size_t b) { \
1897 bool rval = 0; \
1898 bool found; \
1899 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1900 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1901 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1902 wxPyEndBlockThreads(blocked); \
1903 if (! found) \
1904 rval = PCLASS::CBNAME(a,b); \
1905 return rval; \
1906 }
1907
1908
1909
1910 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
1911 bool CBNAME(size_t a) { \
1912 bool rval = 0; \
1913 bool found; \
1914 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1915 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1916 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1917 wxPyEndBlockThreads(blocked); \
1918 if (! found) \
1919 rval = PCLASS::CBNAME(a); \
1920 return rval; \
1921 }
1922
1923
1924 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
1925 wxString CBNAME(int a) { \
1926 bool found; \
1927 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1928 wxString rval; \
1929 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1930 PyObject* ro; \
1931 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
1932 if (ro) { \
1933 rval = Py2wxString(ro); \
1934 Py_DECREF(ro); \
1935 } \
1936 } \
1937 wxPyEndBlockThreads(blocked); \
1938 if (! found) \
1939 rval = PCLASS::CBNAME(a); \
1940 return rval; \
1941 }
1942
1943
1944 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
1945 void CBNAME(int a, const wxString& c) { \
1946 bool found; \
1947 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1948 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1949 PyObject* s = wx2PyString(c); \
1950 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
1951 Py_DECREF(s); \
1952 } \
1953 wxPyEndBlockThreads(blocked); \
1954 if (! found) \
1955 PCLASS::CBNAME(a,c); \
1956 }
1957
1958
1959
1960
1961 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
1962 bool CBNAME() { \
1963 bool rval = 0; \
1964 bool found; \
1965 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1966 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1967 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1968 wxPyEndBlockThreads(blocked); \
1969 if (! found) \
1970 rval = PCLASS::CBNAME(); \
1971 return rval; \
1972 }
1973
1974
1975
1976 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
1977 void CBNAME(size_t a, int b) { \
1978 bool found; \
1979 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1980 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1981 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1982 wxPyEndBlockThreads(blocked); \
1983 if (! found) \
1984 PCLASS::CBNAME(a,b); \
1985 }
1986
1987
1988
1989
1990 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
1991 void CBNAME(int a, int b, long c) { \
1992 bool found; \
1993 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1994 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1995 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1996 wxPyEndBlockThreads(blocked); \
1997 if (! found) \
1998 PCLASS::CBNAME(a,b,c); \
1999 }
2000
2001
2002
2003
2004 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
2005 void CBNAME(int a, int b, double c) { \
2006 bool found; \
2007 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2008 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2009 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
2010 wxPyEndBlockThreads(blocked); \
2011 if (! found) \
2012 PCLASS::CBNAME(a,b,c); \
2013 }
2014
2015
2016
2017 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
2018 void CBNAME(int a, int b, bool c) { \
2019 bool found; \
2020 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2021 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2022 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
2023 wxPyEndBlockThreads(blocked); \
2024 if (! found) \
2025 PCLASS::CBNAME(a,b,c); \
2026 }
2027
2028
2029
2030
2031
2032 SWIGINTERN PyObject *
2033 SWIG_FromCharPtr(const char* cptr)
2034 {
2035 if (cptr) {
2036 size_t size = strlen(cptr);
2037 if (size > INT_MAX) {
2038 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2039 SWIG_TypeQuery("char *"), 0);
2040 } else {
2041 if (size != 0) {
2042 return PyString_FromStringAndSize(cptr, size);
2043 } else {
2044 return PyString_FromString(cptr);
2045 }
2046 }
2047 }
2048 Py_INCREF(Py_None);
2049 return Py_None;
2050 }
2051
2052
2053 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
2054 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
2055 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
2056 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
2057 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
2058 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
2059 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
2060 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
2061 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
2062 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
2063
2064
2065 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2066 #define SWIG_From_int PyInt_FromLong
2067 /*@@*/
2068
2069 static void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
2070 if (!self->GetClientObject())
2071 self->SetClientObject(new wxPyOORClientData(_self));
2072 }
2073
2074 #include <limits.h>
2075
2076
2077 SWIGINTERN int
2078 SWIG_CheckLongInRange(long value, long min_value, long max_value,
2079 const char *errmsg)
2080 {
2081 if (value < min_value) {
2082 if (errmsg) {
2083 PyErr_Format(PyExc_OverflowError,
2084 "value %ld is less than '%s' minimum %ld",
2085 value, errmsg, min_value);
2086 }
2087 return 0;
2088 } else if (value > max_value) {
2089 if (errmsg) {
2090 PyErr_Format(PyExc_OverflowError,
2091 "value %ld is greater than '%s' maximum %ld",
2092 value, errmsg, max_value);
2093 }
2094 return 0;
2095 }
2096 return 1;
2097 }
2098
2099
2100 SWIGINTERN int
2101 SWIG_AsVal_long(PyObject* obj, long* val)
2102 {
2103 if (PyNumber_Check(obj)) {
2104 if (val) *val = PyInt_AsLong(obj);
2105 return 1;
2106 }
2107 else {
2108 SWIG_Python_TypeError("number", obj);
2109 }
2110 return 0;
2111 }
2112
2113
2114 #if INT_MAX != LONG_MAX
2115 SWIGINTERN int
2116 SWIG_AsVal_int(PyObject *obj, int *val)
2117 {
2118 const char* errmsg = val ? "int" : (char*)0;
2119 long v;
2120 if (SWIG_AsVal_long(obj, &v)) {
2121 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
2122 if (val) *val = static_cast<int >(v);
2123 return 1;
2124 } else {
2125 return 0;
2126 }
2127 } else {
2128 PyErr_Clear();
2129 }
2130 if (val) {
2131 SWIG_type_error(errmsg, obj);
2132 }
2133 return 0;
2134 }
2135 #else
2136 SWIGINTERNINLINE int
2137 SWIG_AsVal_int(PyObject *obj, int *val)
2138 {
2139 return SWIG_AsVal_long(obj,(long*)val);
2140 }
2141 #endif
2142
2143
2144 SWIGINTERNINLINE int
2145 SWIG_As_int(PyObject* obj)
2146 {
2147 int v;
2148 if (!SWIG_AsVal_int(obj, &v)) {
2149 /*
2150 this is needed to make valgrind/purify happier.
2151 */
2152 memset((void*)&v, 0, sizeof(int));
2153 }
2154 return v;
2155 }
2156
2157
2158 SWIGINTERN int
2159 SWIG_AsVal_bool(PyObject *obj, bool *val)
2160 {
2161 if (obj == Py_True) {
2162 if (val) *val = true;
2163 return 1;
2164 }
2165 if (obj == Py_False) {
2166 if (val) *val = false;
2167 return 1;
2168 }
2169 int res = 0;
2170 if (SWIG_AsVal_int(obj, &res)) {
2171 if (val) *val = res ? true : false;
2172 return 1;
2173 } else {
2174 PyErr_Clear();
2175 }
2176 if (val) {
2177 SWIG_type_error("bool", obj);
2178 }
2179 return 0;
2180 }
2181
2182
2183 SWIGINTERNINLINE bool
2184 SWIG_As_bool(PyObject* obj)
2185 {
2186 bool v;
2187 if (!SWIG_AsVal_bool(obj, &v)) {
2188 /*
2189 this is needed to make valgrind/purify happier.
2190 */
2191 memset((void*)&v, 0, sizeof(bool));
2192 }
2193 return v;
2194 }
2195
2196
2197 SWIGINTERNINLINE int
2198 SWIG_Check_int(PyObject* obj)
2199 {
2200 return SWIG_AsVal_int(obj, (int*)0);
2201 }
2202
2203
2204 SWIGINTERNINLINE int
2205 SWIG_Check_bool(PyObject* obj)
2206 {
2207 return SWIG_AsVal_bool(obj, (bool*)0);
2208 }
2209
2210
2211 class wxPyGridCellRenderer : public wxGridCellRenderer
2212 {
2213 public:
2214 wxPyGridCellRenderer() : wxGridCellRenderer() {};
2215
2216 // Implement Python callback aware virtual methods
2217 void Draw(wxGrid& grid, wxGridCellAttr& attr,
2218 wxDC& dc, const wxRect& rect,
2219 int row, int col, bool isSelected) {
2220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2221 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
2222 PyObject* go = wxPyMake_wxObject(&grid,false);
2223 PyObject* dco = wxPyMake_wxObject(&dc,false);
2224 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2225 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
2226
2227 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
2228 row, col, isSelected));
2229 Py_DECREF(go);
2230 Py_DECREF(ao);
2231 Py_DECREF(dco);
2232 Py_DECREF(ro);
2233 }
2234 wxPyEndBlockThreads(blocked);
2235 }
2236
2237 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
2238 int row, int col) {
2239 wxSize rval;
2240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2241 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
2242 PyObject* ro;
2243 wxSize* ptr;
2244 PyObject* go = wxPyMake_wxObject(&grid,false);
2245 PyObject* dco = wxPyMake_wxObject(&dc,false);
2246 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2247
2248 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
2249 go, ao, dco,
2250 row, col));
2251 Py_DECREF(go);
2252 Py_DECREF(ao);
2253 Py_DECREF(dco);
2254
2255 if (ro) {
2256 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
2257 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
2258 rval = *ptr;
2259 }
2260 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
2261 PyObject* o1 = PySequence_GetItem(ro, 0);
2262 PyObject* o2 = PySequence_GetItem(ro, 1);
2263 if (PyNumber_Check(o1) && PyNumber_Check(o2))
2264 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
2265 else
2266 PyErr_SetString(PyExc_TypeError, errmsg);
2267 Py_DECREF(o1);
2268 Py_DECREF(o2);
2269 }
2270 else {
2271 PyErr_SetString(PyExc_TypeError, errmsg);
2272 }
2273 Py_DECREF(ro);
2274 }
2275 }
2276 wxPyEndBlockThreads(blocked);
2277 return rval;
2278 }
2279
2280
2281 wxGridCellRenderer *Clone() const {
2282 wxGridCellRenderer* rval = NULL;
2283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2284 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2285 PyObject* ro;
2286 wxGridCellRenderer* ptr;
2287 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2288 if (ro) {
2289 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
2290 rval = ptr;
2291 Py_DECREF(ro);
2292 }
2293 }
2294 wxPyEndBlockThreads(blocked);
2295 return rval;
2296 }
2297
2298 DEC_PYCALLBACK__STRING(SetParameters);
2299
2300 PYPRIVATE;
2301 };
2302
2303 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
2304
2305
2306 static void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
2307 if (!self->GetClientObject())
2308 self->SetClientObject(new wxPyOORClientData(_self));
2309 }
2310
2311 class wxPyGridCellEditor : public wxGridCellEditor
2312 {
2313 public:
2314 wxPyGridCellEditor() : wxGridCellEditor() {}
2315
2316 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
2317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2318 if (wxPyCBH_findCallback(m_myInst, "Create")) {
2319 PyObject* po = wxPyMake_wxObject(parent,false);
2320 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
2321
2322 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
2323 Py_DECREF(po);
2324 Py_DECREF(eo);
2325 }
2326 wxPyEndBlockThreads(blocked);
2327 }
2328
2329
2330 void BeginEdit(int row, int col, wxGrid* grid) {
2331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2332 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
2333 PyObject* go = wxPyMake_wxObject(grid,false);
2334 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2335 Py_DECREF(go);
2336 }
2337 wxPyEndBlockThreads(blocked);
2338 }
2339
2340
2341 bool EndEdit(int row, int col, wxGrid* grid) {
2342 bool rv = false;
2343 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2344 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
2345 PyObject* go = wxPyMake_wxObject(grid,false);
2346 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2347 Py_DECREF(go);
2348 }
2349 wxPyEndBlockThreads(blocked);
2350 return rv;
2351 }
2352
2353
2354 wxGridCellEditor* Clone() const {
2355 wxGridCellEditor* rval = NULL;
2356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2357 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2358 PyObject* ro;
2359 wxGridCellEditor* ptr;
2360 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2361 if (ro) {
2362 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
2363 rval = ptr;
2364 Py_DECREF(ro);
2365 }
2366 }
2367 wxPyEndBlockThreads(blocked);
2368 return rval;
2369 }
2370
2371
2372 void Show(bool show, wxGridCellAttr *attr) {
2373 bool found;
2374 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2375 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
2376 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2377 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
2378 Py_DECREF(ao);
2379 }
2380 wxPyEndBlockThreads(blocked);
2381 if (! found)
2382 wxGridCellEditor::Show(show, attr);
2383 }
2384
2385
2386 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2387 bool found;
2388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2389 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
2390 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2391 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
2392
2393 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
2394
2395 Py_DECREF(ro);
2396 Py_DECREF(ao);
2397 }
2398 wxPyEndBlockThreads(blocked);
2399 if (! found)
2400 wxGridCellEditor::PaintBackground(rectCell, attr);
2401 }
2402
2403
2404 DEC_PYCALLBACK___pure(Reset);
2405 DEC_PYCALLBACK__constany(SetSize, wxRect);
2406 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
2407 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
2408 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
2409 DEC_PYCALLBACK__(StartingClick);
2410 DEC_PYCALLBACK__(Destroy);
2411 DEC_PYCALLBACK__STRING(SetParameters);
2412 DEC_PYCALLBACK_STRING__constpure(GetValue);
2413
2414 PYPRIVATE;
2415 };
2416
2417
2418 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
2419 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
2420 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
2421 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
2422 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
2423 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
2424 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
2425 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
2426 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
2427
2428
2429 static void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
2430 if (!self->GetClientObject())
2431 self->SetClientObject(new wxPyOORClientData(_self));
2432 }
2433
2434 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2435 {
2436 PyObject* o2;
2437 PyObject* o3;
2438 if (!result) {
2439 result = obj;
2440 } else if (result == Py_None) {
2441 Py_DECREF(result);
2442 result = obj;
2443 } else {
2444 if (!PyTuple_Check(result)) {
2445 o2 = result;
2446 result = PyTuple_New(1);
2447 PyTuple_SET_ITEM(result, 0, o2);
2448 }
2449 o3 = PyTuple_New(1);
2450 PyTuple_SetItem(o3, 0, obj);
2451 o2 = result;
2452 result = PySequence_Concat(o2, o3);
2453 Py_DECREF(o2);
2454 Py_DECREF(o3);
2455 }
2456 return result;
2457 }
2458
2459
2460 static void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
2461 if (!self->GetClientObject())
2462 self->SetClientObject(new wxPyOORClientData(_self));
2463 }
2464
2465 SWIGINTERN int
2466 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2467 {
2468 long v = 0;
2469 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2470 SWIG_Python_TypeError("unsigned number", obj);
2471 }
2472 else if (val)
2473 *val = (unsigned long)v;
2474 return 1;
2475 }
2476
2477
2478 SWIGINTERNINLINE unsigned long
2479 SWIG_As_unsigned_SS_long(PyObject* obj)
2480 {
2481 unsigned long v;
2482 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2483 /*
2484 this is needed to make valgrind/purify happier.
2485 */
2486 memset((void*)&v, 0, sizeof(unsigned long));
2487 }
2488 return v;
2489 }
2490
2491
2492 SWIGINTERNINLINE int
2493 SWIG_Check_unsigned_SS_long(PyObject* obj)
2494 {
2495 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2496 }
2497
2498
2499 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
2500 {
2501 public:
2502 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
2503
2504 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
2505 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
2506 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
2507 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
2508
2509 PYPRIVATE;
2510 };
2511
2512 static void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
2513 if (!self->GetClientObject())
2514 self->SetClientObject(new wxPyOORClientData(_self));
2515 }
2516
2517 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2518 #define SWIG_From_long PyInt_FromLong
2519 /*@@*/
2520
2521
2522 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2523 #define SWIG_From_double PyFloat_FromDouble
2524 /*@@*/
2525
2526
2527 SWIGINTERNINLINE long
2528 SWIG_As_long(PyObject* obj)
2529 {
2530 long v;
2531 if (!SWIG_AsVal_long(obj, &v)) {
2532 /*
2533 this is needed to make valgrind/purify happier.
2534 */
2535 memset((void*)&v, 0, sizeof(long));
2536 }
2537 return v;
2538 }
2539
2540
2541 SWIGINTERNINLINE int
2542 SWIG_Check_long(PyObject* obj)
2543 {
2544 return SWIG_AsVal_long(obj, (long*)0);
2545 }
2546
2547
2548 SWIGINTERN int
2549 SWIG_AsVal_double(PyObject *obj, double* val)
2550 {
2551 if (PyNumber_Check(obj)) {
2552 if (val) *val = PyFloat_AsDouble(obj);
2553 return 1;
2554 }
2555 else {
2556 SWIG_Python_TypeError("number", obj);
2557 }
2558 return 0;
2559 }
2560
2561
2562 SWIGINTERNINLINE double
2563 SWIG_As_double(PyObject* obj)
2564 {
2565 double v;
2566 if (!SWIG_AsVal_double(obj, &v)) {
2567 /*
2568 this is needed to make valgrind/purify happier.
2569 */
2570 memset((void*)&v, 0, sizeof(double));
2571 }
2572 return v;
2573 }
2574
2575
2576 SWIGINTERNINLINE int
2577 SWIG_Check_double(PyObject* obj)
2578 {
2579 return SWIG_AsVal_double(obj, (double*)0);
2580 }
2581
2582
2583 class wxPyGridTableBase : public wxGridTableBase
2584 {
2585 public:
2586 wxPyGridTableBase() : wxGridTableBase() {}
2587
2588 PYCALLBACK_INT__pure(GetNumberRows);
2589 PYCALLBACK_INT__pure(GetNumberCols);
2590 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
2591 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
2592 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
2593 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
2594 PYCALLBACK__(wxGridTableBase, Clear);
2595 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
2596 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
2597 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
2598 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
2599 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
2600 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
2601 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
2602 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
2603 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
2604 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
2605 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
2606 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
2607 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
2608 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
2609 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
2610
2611
2612 wxString GetValue(int row, int col) {
2613 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2614 wxString rval;
2615 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2616 PyObject* ro;
2617 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
2618 if (ro) {
2619 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
2620 PyObject* old = ro;
2621 ro = PyObject_Str(ro);
2622 Py_DECREF(old);
2623 }
2624 rval = Py2wxString(ro);
2625 Py_DECREF(ro);
2626 }
2627 }
2628 wxPyEndBlockThreads(blocked);
2629 return rval;
2630 }
2631
2632 void SetValue(int row, int col, const wxString& val) {
2633 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2634 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2635 PyObject* s = wx2PyString(val);
2636 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
2637 Py_DECREF(s);
2638 }
2639 wxPyEndBlockThreads(blocked);
2640 }
2641
2642
2643 // Map the Get/Set methods for the standard non-string types to
2644 // the GetValue and SetValue python methods.
2645 long GetValueAsLong( int row, int col ) {
2646 long rval = 0;
2647 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2648 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2649 PyObject* ro;
2650 PyObject* num;
2651 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2652 if (ro && PyNumber_Check(ro)) {
2653 num = PyNumber_Int(ro);
2654 if (num) {
2655 rval = PyInt_AsLong(num);
2656 Py_DECREF(num);
2657 }
2658 Py_DECREF(ro);
2659 }
2660 }
2661 wxPyEndBlockThreads(blocked);
2662 return rval;
2663 }
2664
2665 double GetValueAsDouble( int row, int col ) {
2666 double rval = 0.0;
2667 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2668 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2669 PyObject* ro;
2670 PyObject* num;
2671 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2672 if (ro && PyNumber_Check(ro)) {
2673 num = PyNumber_Float(ro);
2674 if (num) {
2675 rval = PyFloat_AsDouble(num);
2676 Py_DECREF(num);
2677 }
2678 Py_DECREF(ro);
2679 }
2680 }
2681 wxPyEndBlockThreads(blocked);
2682 return rval;
2683 }
2684
2685 bool GetValueAsBool( int row, int col ) {
2686 return (bool)GetValueAsLong(row, col);
2687 }
2688
2689 void SetValueAsLong( int row, int col, long value ) {
2690 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2691 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2692 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
2693 }
2694 wxPyEndBlockThreads(blocked);
2695 }
2696
2697 void SetValueAsDouble( int row, int col, double value ) {
2698 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2699 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2700 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
2701 }
2702 wxPyEndBlockThreads(blocked);
2703 }
2704
2705 void SetValueAsBool( int row, int col, bool value ) {
2706 SetValueAsLong( row, col, (long)value );
2707 }
2708
2709
2710 PYPRIVATE;
2711 };
2712
2713 static void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
2714
2715 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
2716
2717 if (source == Py_None) {
2718 **obj = wxGridCellCoords(-1,-1);
2719 return true;
2720 }
2721
2722 // If source is an object instance then it may already be the right type
2723 if (wxPySwigInstance_Check(source)) {
2724 wxGridCellCoords* ptr;
2725 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2726 goto error;
2727 *obj = ptr;
2728 return true;
2729 }
2730 // otherwise a 2-tuple of integers is expected
2731 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2732 PyObject* o1 = PySequence_GetItem(source, 0);
2733 PyObject* o2 = PySequence_GetItem(source, 1);
2734 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2735 Py_DECREF(o1);
2736 Py_DECREF(o2);
2737 goto error;
2738 }
2739 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
2740 Py_DECREF(o1);
2741 Py_DECREF(o2);
2742 return true;
2743 }
2744
2745 error:
2746 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
2747 return false;
2748 }
2749
2750
2751 bool wxGridCellCoords_typecheck(PyObject* source) {
2752 void* ptr;
2753
2754 if (wxPySwigInstance_Check(source) &&
2755 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2756 return true;
2757
2758 PyErr_Clear();
2759 if (PySequence_Check(source) && PySequence_Length(source) == 2)
2760 return true;
2761
2762 return false;
2763 }
2764
2765
2766 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
2767 {
2768 PyObject* list = PyList_New(0);
2769 size_t idx;
2770 for (idx = 0; idx < source.GetCount(); idx += 1) {
2771 wxGridCellCoords& coord = source.Item(idx);
2772 PyObject* tup = PyTuple_New(2);
2773 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
2774 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
2775 PyList_Append(list, tup);
2776 Py_DECREF(tup);
2777 }
2778 return list;
2779 }
2780
2781 static PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
2782 PyObject* tup = PyTuple_New(2);
2783 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
2784 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
2785 return tup;
2786 }
2787
2788 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
2789
2790
2791 static wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
2792 wxGridCellCoords rv;
2793 self->XYToCell(x, y, rv);
2794 return rv;
2795 }
2796 #ifdef __cplusplus
2797 extern "C" {
2798 #endif
2799 static int _wrap_GridNoCellCoords_set(PyObject *) {
2800 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2801 return 1;
2802 }
2803
2804
2805 static PyObject *_wrap_GridNoCellCoords_get(void) {
2806 PyObject *pyobj = NULL;
2807
2808 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2809 return pyobj;
2810 }
2811
2812
2813 static int _wrap_GridNoCellRect_set(PyObject *) {
2814 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2815 return 1;
2816 }
2817
2818
2819 static PyObject *_wrap_GridNoCellRect_get(void) {
2820 PyObject *pyobj = NULL;
2821
2822 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2823 return pyobj;
2824 }
2825
2826
2827 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2828 PyObject *resultobj = NULL;
2829 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2830 PyObject *arg2 = (PyObject *) 0 ;
2831 PyObject * obj0 = 0 ;
2832 PyObject * obj1 = 0 ;
2833 char *kwnames[] = {
2834 (char *) "self",(char *) "_self", NULL
2835 };
2836
2837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2839 if (SWIG_arg_fail(1)) SWIG_fail;
2840 arg2 = obj1;
2841 {
2842 PyThreadState* __tstate = wxPyBeginAllowThreads();
2843 wxGridCellRenderer__setOORInfo(arg1,arg2);
2844
2845 wxPyEndAllowThreads(__tstate);
2846 if (PyErr_Occurred()) SWIG_fail;
2847 }
2848 Py_INCREF(Py_None); resultobj = Py_None;
2849 return resultobj;
2850 fail:
2851 return NULL;
2852 }
2853
2854
2855 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2856 PyObject *resultobj = NULL;
2857 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2858 wxString *arg2 = 0 ;
2859 bool temp2 = false ;
2860 PyObject * obj0 = 0 ;
2861 PyObject * obj1 = 0 ;
2862 char *kwnames[] = {
2863 (char *) "self",(char *) "params", NULL
2864 };
2865
2866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2868 if (SWIG_arg_fail(1)) SWIG_fail;
2869 {
2870 arg2 = wxString_in_helper(obj1);
2871 if (arg2 == NULL) SWIG_fail;
2872 temp2 = true;
2873 }
2874 {
2875 PyThreadState* __tstate = wxPyBeginAllowThreads();
2876 (arg1)->SetParameters((wxString const &)*arg2);
2877
2878 wxPyEndAllowThreads(__tstate);
2879 if (PyErr_Occurred()) SWIG_fail;
2880 }
2881 Py_INCREF(Py_None); resultobj = Py_None;
2882 {
2883 if (temp2)
2884 delete arg2;
2885 }
2886 return resultobj;
2887 fail:
2888 {
2889 if (temp2)
2890 delete arg2;
2891 }
2892 return NULL;
2893 }
2894
2895
2896 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2897 PyObject *resultobj = NULL;
2898 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2899 PyObject * obj0 = 0 ;
2900 char *kwnames[] = {
2901 (char *) "self", NULL
2902 };
2903
2904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2906 if (SWIG_arg_fail(1)) SWIG_fail;
2907 {
2908 PyThreadState* __tstate = wxPyBeginAllowThreads();
2909 (arg1)->IncRef();
2910
2911 wxPyEndAllowThreads(__tstate);
2912 if (PyErr_Occurred()) SWIG_fail;
2913 }
2914 Py_INCREF(Py_None); resultobj = Py_None;
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj = NULL;
2923 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2924 PyObject * obj0 = 0 ;
2925 char *kwnames[] = {
2926 (char *) "self", NULL
2927 };
2928
2929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2931 if (SWIG_arg_fail(1)) SWIG_fail;
2932 {
2933 PyThreadState* __tstate = wxPyBeginAllowThreads();
2934 (arg1)->DecRef();
2935
2936 wxPyEndAllowThreads(__tstate);
2937 if (PyErr_Occurred()) SWIG_fail;
2938 }
2939 Py_INCREF(Py_None); resultobj = Py_None;
2940 return resultobj;
2941 fail:
2942 return NULL;
2943 }
2944
2945
2946 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
2947 PyObject *resultobj = NULL;
2948 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2949 wxGrid *arg2 = 0 ;
2950 wxGridCellAttr *arg3 = 0 ;
2951 wxDC *arg4 = 0 ;
2952 wxRect *arg5 = 0 ;
2953 int arg6 ;
2954 int arg7 ;
2955 bool arg8 ;
2956 wxRect temp5 ;
2957 PyObject * obj0 = 0 ;
2958 PyObject * obj1 = 0 ;
2959 PyObject * obj2 = 0 ;
2960 PyObject * obj3 = 0 ;
2961 PyObject * obj4 = 0 ;
2962 PyObject * obj5 = 0 ;
2963 PyObject * obj6 = 0 ;
2964 PyObject * obj7 = 0 ;
2965 char *kwnames[] = {
2966 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
2967 };
2968
2969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2971 if (SWIG_arg_fail(1)) SWIG_fail;
2972 {
2973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2974 if (SWIG_arg_fail(2)) SWIG_fail;
2975 if (arg2 == NULL) {
2976 SWIG_null_ref("wxGrid");
2977 }
2978 if (SWIG_arg_fail(2)) SWIG_fail;
2979 }
2980 {
2981 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2982 if (SWIG_arg_fail(3)) SWIG_fail;
2983 if (arg3 == NULL) {
2984 SWIG_null_ref("wxGridCellAttr");
2985 }
2986 if (SWIG_arg_fail(3)) SWIG_fail;
2987 }
2988 {
2989 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2990 if (SWIG_arg_fail(4)) SWIG_fail;
2991 if (arg4 == NULL) {
2992 SWIG_null_ref("wxDC");
2993 }
2994 if (SWIG_arg_fail(4)) SWIG_fail;
2995 }
2996 {
2997 arg5 = &temp5;
2998 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
2999 }
3000 {
3001 arg6 = static_cast<int >(SWIG_As_int(obj5));
3002 if (SWIG_arg_fail(6)) SWIG_fail;
3003 }
3004 {
3005 arg7 = static_cast<int >(SWIG_As_int(obj6));
3006 if (SWIG_arg_fail(7)) SWIG_fail;
3007 }
3008 {
3009 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
3010 if (SWIG_arg_fail(8)) SWIG_fail;
3011 }
3012 {
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 Py_INCREF(Py_None); resultobj = Py_None;
3020 return resultobj;
3021 fail:
3022 return NULL;
3023 }
3024
3025
3026 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
3027 PyObject *resultobj = NULL;
3028 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3029 wxGrid *arg2 = 0 ;
3030 wxGridCellAttr *arg3 = 0 ;
3031 wxDC *arg4 = 0 ;
3032 int arg5 ;
3033 int arg6 ;
3034 wxSize result;
3035 PyObject * obj0 = 0 ;
3036 PyObject * obj1 = 0 ;
3037 PyObject * obj2 = 0 ;
3038 PyObject * obj3 = 0 ;
3039 PyObject * obj4 = 0 ;
3040 PyObject * obj5 = 0 ;
3041 char *kwnames[] = {
3042 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
3043 };
3044
3045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3047 if (SWIG_arg_fail(1)) SWIG_fail;
3048 {
3049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3050 if (SWIG_arg_fail(2)) SWIG_fail;
3051 if (arg2 == NULL) {
3052 SWIG_null_ref("wxGrid");
3053 }
3054 if (SWIG_arg_fail(2)) SWIG_fail;
3055 }
3056 {
3057 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3058 if (SWIG_arg_fail(3)) SWIG_fail;
3059 if (arg3 == NULL) {
3060 SWIG_null_ref("wxGridCellAttr");
3061 }
3062 if (SWIG_arg_fail(3)) SWIG_fail;
3063 }
3064 {
3065 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3066 if (SWIG_arg_fail(4)) SWIG_fail;
3067 if (arg4 == NULL) {
3068 SWIG_null_ref("wxDC");
3069 }
3070 if (SWIG_arg_fail(4)) SWIG_fail;
3071 }
3072 {
3073 arg5 = static_cast<int >(SWIG_As_int(obj4));
3074 if (SWIG_arg_fail(5)) SWIG_fail;
3075 }
3076 {
3077 arg6 = static_cast<int >(SWIG_As_int(obj5));
3078 if (SWIG_arg_fail(6)) SWIG_fail;
3079 }
3080 {
3081 PyThreadState* __tstate = wxPyBeginAllowThreads();
3082 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
3083
3084 wxPyEndAllowThreads(__tstate);
3085 if (PyErr_Occurred()) SWIG_fail;
3086 }
3087 {
3088 wxSize * resultptr;
3089 resultptr = new wxSize(static_cast<wxSize & >(result));
3090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3091 }
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3099 PyObject *resultobj = NULL;
3100 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3101 wxGridCellRenderer *result;
3102 PyObject * obj0 = 0 ;
3103 char *kwnames[] = {
3104 (char *) "self", NULL
3105 };
3106
3107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
3108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3109 if (SWIG_arg_fail(1)) SWIG_fail;
3110 {
3111 PyThreadState* __tstate = wxPyBeginAllowThreads();
3112 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
3113
3114 wxPyEndAllowThreads(__tstate);
3115 if (PyErr_Occurred()) SWIG_fail;
3116 }
3117 {
3118 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
3119 }
3120 return resultobj;
3121 fail:
3122 return NULL;
3123 }
3124
3125
3126 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
3127 PyObject *obj;
3128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3129 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
3130 Py_INCREF(obj);
3131 return Py_BuildValue((char *)"");
3132 }
3133 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3134 PyObject *resultobj = NULL;
3135 wxPyGridCellRenderer *result;
3136 char *kwnames[] = {
3137 NULL
3138 };
3139
3140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
3141 {
3142 PyThreadState* __tstate = wxPyBeginAllowThreads();
3143 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3144
3145 wxPyEndAllowThreads(__tstate);
3146 if (PyErr_Occurred()) SWIG_fail;
3147 }
3148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
3149 return resultobj;
3150 fail:
3151 return NULL;
3152 }
3153
3154
3155 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3156 PyObject *resultobj = NULL;
3157 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3158 PyObject *arg2 = (PyObject *) 0 ;
3159 PyObject *arg3 = (PyObject *) 0 ;
3160 PyObject * obj0 = 0 ;
3161 PyObject * obj1 = 0 ;
3162 PyObject * obj2 = 0 ;
3163 char *kwnames[] = {
3164 (char *) "self",(char *) "self",(char *) "_class", NULL
3165 };
3166
3167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3169 if (SWIG_arg_fail(1)) SWIG_fail;
3170 arg2 = obj1;
3171 arg3 = obj2;
3172 {
3173 PyThreadState* __tstate = wxPyBeginAllowThreads();
3174 (arg1)->_setCallbackInfo(arg2,arg3);
3175
3176 wxPyEndAllowThreads(__tstate);
3177 if (PyErr_Occurred()) SWIG_fail;
3178 }
3179 Py_INCREF(Py_None); resultobj = Py_None;
3180 return resultobj;
3181 fail:
3182 return NULL;
3183 }
3184
3185
3186 static PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3187 PyObject *resultobj = NULL;
3188 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3189 wxString *arg2 = 0 ;
3190 bool temp2 = false ;
3191 PyObject * obj0 = 0 ;
3192 PyObject * obj1 = 0 ;
3193 char *kwnames[] = {
3194 (char *) "self",(char *) "params", NULL
3195 };
3196
3197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3199 if (SWIG_arg_fail(1)) SWIG_fail;
3200 {
3201 arg2 = wxString_in_helper(obj1);
3202 if (arg2 == NULL) SWIG_fail;
3203 temp2 = true;
3204 }
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 (arg1)->SetParameters((wxString const &)*arg2);
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 Py_INCREF(Py_None); resultobj = Py_None;
3213 {
3214 if (temp2)
3215 delete arg2;
3216 }
3217 return resultobj;
3218 fail:
3219 {
3220 if (temp2)
3221 delete arg2;
3222 }
3223 return NULL;
3224 }
3225
3226
3227 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3228 PyObject *obj;
3229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3230 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3231 Py_INCREF(obj);
3232 return Py_BuildValue((char *)"");
3233 }
3234 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3235 PyObject *resultobj = NULL;
3236 wxGridCellStringRenderer *result;
3237 char *kwnames[] = {
3238 NULL
3239 };
3240
3241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3250 return resultobj;
3251 fail:
3252 return NULL;
3253 }
3254
3255
3256 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3257 PyObject *obj;
3258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3259 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3260 Py_INCREF(obj);
3261 return Py_BuildValue((char *)"");
3262 }
3263 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3264 PyObject *resultobj = NULL;
3265 wxGridCellNumberRenderer *result;
3266 char *kwnames[] = {
3267 NULL
3268 };
3269
3270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3271 {
3272 PyThreadState* __tstate = wxPyBeginAllowThreads();
3273 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3274
3275 wxPyEndAllowThreads(__tstate);
3276 if (PyErr_Occurred()) SWIG_fail;
3277 }
3278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3279 return resultobj;
3280 fail:
3281 return NULL;
3282 }
3283
3284
3285 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3286 PyObject *obj;
3287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3288 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3289 Py_INCREF(obj);
3290 return Py_BuildValue((char *)"");
3291 }
3292 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3293 PyObject *resultobj = NULL;
3294 int arg1 = (int) -1 ;
3295 int arg2 = (int) -1 ;
3296 wxGridCellFloatRenderer *result;
3297 PyObject * obj0 = 0 ;
3298 PyObject * obj1 = 0 ;
3299 char *kwnames[] = {
3300 (char *) "width",(char *) "precision", NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3304 if (obj0) {
3305 {
3306 arg1 = static_cast<int >(SWIG_As_int(obj0));
3307 if (SWIG_arg_fail(1)) SWIG_fail;
3308 }
3309 }
3310 if (obj1) {
3311 {
3312 arg2 = static_cast<int >(SWIG_As_int(obj1));
3313 if (SWIG_arg_fail(2)) SWIG_fail;
3314 }
3315 }
3316 {
3317 PyThreadState* __tstate = wxPyBeginAllowThreads();
3318 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3319
3320 wxPyEndAllowThreads(__tstate);
3321 if (PyErr_Occurred()) SWIG_fail;
3322 }
3323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3324 return resultobj;
3325 fail:
3326 return NULL;
3327 }
3328
3329
3330 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3331 PyObject *resultobj = NULL;
3332 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3333 int result;
3334 PyObject * obj0 = 0 ;
3335 char *kwnames[] = {
3336 (char *) "self", NULL
3337 };
3338
3339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3341 if (SWIG_arg_fail(1)) SWIG_fail;
3342 {
3343 PyThreadState* __tstate = wxPyBeginAllowThreads();
3344 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3345
3346 wxPyEndAllowThreads(__tstate);
3347 if (PyErr_Occurred()) SWIG_fail;
3348 }
3349 {
3350 resultobj = SWIG_From_int(static_cast<int >(result));
3351 }
3352 return resultobj;
3353 fail:
3354 return NULL;
3355 }
3356
3357
3358 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj = NULL;
3360 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3361 int arg2 ;
3362 PyObject * obj0 = 0 ;
3363 PyObject * obj1 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "self",(char *) "width", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3370 if (SWIG_arg_fail(1)) SWIG_fail;
3371 {
3372 arg2 = static_cast<int >(SWIG_As_int(obj1));
3373 if (SWIG_arg_fail(2)) SWIG_fail;
3374 }
3375 {
3376 PyThreadState* __tstate = wxPyBeginAllowThreads();
3377 (arg1)->SetWidth(arg2);
3378
3379 wxPyEndAllowThreads(__tstate);
3380 if (PyErr_Occurred()) SWIG_fail;
3381 }
3382 Py_INCREF(Py_None); resultobj = Py_None;
3383 return resultobj;
3384 fail:
3385 return NULL;
3386 }
3387
3388
3389 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj = NULL;
3391 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3392 int result;
3393 PyObject * obj0 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "self", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3400 if (SWIG_arg_fail(1)) SWIG_fail;
3401 {
3402 PyThreadState* __tstate = wxPyBeginAllowThreads();
3403 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3404
3405 wxPyEndAllowThreads(__tstate);
3406 if (PyErr_Occurred()) SWIG_fail;
3407 }
3408 {
3409 resultobj = SWIG_From_int(static_cast<int >(result));
3410 }
3411 return resultobj;
3412 fail:
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj = NULL;
3419 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3420 int arg2 ;
3421 PyObject * obj0 = 0 ;
3422 PyObject * obj1 = 0 ;
3423 char *kwnames[] = {
3424 (char *) "self",(char *) "precision", NULL
3425 };
3426
3427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3429 if (SWIG_arg_fail(1)) SWIG_fail;
3430 {
3431 arg2 = static_cast<int >(SWIG_As_int(obj1));
3432 if (SWIG_arg_fail(2)) SWIG_fail;
3433 }
3434 {
3435 PyThreadState* __tstate = wxPyBeginAllowThreads();
3436 (arg1)->SetPrecision(arg2);
3437
3438 wxPyEndAllowThreads(__tstate);
3439 if (PyErr_Occurred()) SWIG_fail;
3440 }
3441 Py_INCREF(Py_None); resultobj = Py_None;
3442 return resultobj;
3443 fail:
3444 return NULL;
3445 }
3446
3447
3448 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3449 PyObject *obj;
3450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3451 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3452 Py_INCREF(obj);
3453 return Py_BuildValue((char *)"");
3454 }
3455 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj = NULL;
3457 wxGridCellBoolRenderer *result;
3458 char *kwnames[] = {
3459 NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3463 {
3464 PyThreadState* __tstate = wxPyBeginAllowThreads();
3465 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3466
3467 wxPyEndAllowThreads(__tstate);
3468 if (PyErr_Occurred()) SWIG_fail;
3469 }
3470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3471 return resultobj;
3472 fail:
3473 return NULL;
3474 }
3475
3476
3477 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3478 PyObject *obj;
3479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3480 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3481 Py_INCREF(obj);
3482 return Py_BuildValue((char *)"");
3483 }
3484 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3485 PyObject *resultobj = NULL;
3486 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
3487 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
3488 wxGridCellDateTimeRenderer *result;
3489 PyObject * obj0 = 0 ;
3490 PyObject * obj1 = 0 ;
3491 char *kwnames[] = {
3492 (char *) "outformat",(char *) "informat", NULL
3493 };
3494
3495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3496 if (obj0) {
3497 {
3498 wxString* sptr = wxString_in_helper(obj0);
3499 if (sptr == NULL) SWIG_fail;
3500 arg1 = *sptr;
3501 delete sptr;
3502 }
3503 }
3504 if (obj1) {
3505 {
3506 wxString* sptr = wxString_in_helper(obj1);
3507 if (sptr == NULL) SWIG_fail;
3508 arg2 = *sptr;
3509 delete sptr;
3510 }
3511 }
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3520 return resultobj;
3521 fail:
3522 return NULL;
3523 }
3524
3525
3526 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3527 PyObject *obj;
3528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3529 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3530 Py_INCREF(obj);
3531 return Py_BuildValue((char *)"");
3532 }
3533 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3534 PyObject *resultobj = NULL;
3535 wxString const &arg1_defvalue = wxPyEmptyString ;
3536 wxString *arg1 = (wxString *) &arg1_defvalue ;
3537 wxGridCellEnumRenderer *result;
3538 bool temp1 = false ;
3539 PyObject * obj0 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "choices", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3545 if (obj0) {
3546 {
3547 arg1 = wxString_in_helper(obj0);
3548 if (arg1 == NULL) SWIG_fail;
3549 temp1 = true;
3550 }
3551 }
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3560 {
3561 if (temp1)
3562 delete arg1;
3563 }
3564 return resultobj;
3565 fail:
3566 {
3567 if (temp1)
3568 delete arg1;
3569 }
3570 return NULL;
3571 }
3572
3573
3574 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3575 PyObject *obj;
3576 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3577 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3578 Py_INCREF(obj);
3579 return Py_BuildValue((char *)"");
3580 }
3581 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj = NULL;
3583 wxGridCellAutoWrapStringRenderer *result;
3584 char *kwnames[] = {
3585 NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3604 PyObject *obj;
3605 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3606 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3607 Py_INCREF(obj);
3608 return Py_BuildValue((char *)"");
3609 }
3610 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3611 PyObject *resultobj = NULL;
3612 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3613 PyObject *arg2 = (PyObject *) 0 ;
3614 PyObject * obj0 = 0 ;
3615 PyObject * obj1 = 0 ;
3616 char *kwnames[] = {
3617 (char *) "self",(char *) "_self", NULL
3618 };
3619
3620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(1)) SWIG_fail;
3623 arg2 = obj1;
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 wxGridCellEditor__setOORInfo(arg1,arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 Py_INCREF(Py_None); resultobj = Py_None;
3632 return resultobj;
3633 fail:
3634 return NULL;
3635 }
3636
3637
3638 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3639 PyObject *resultobj = NULL;
3640 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3641 bool result;
3642 PyObject * obj0 = 0 ;
3643 char *kwnames[] = {
3644 (char *) "self", NULL
3645 };
3646
3647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3649 if (SWIG_arg_fail(1)) SWIG_fail;
3650 {
3651 PyThreadState* __tstate = wxPyBeginAllowThreads();
3652 result = (bool)(arg1)->IsCreated();
3653
3654 wxPyEndAllowThreads(__tstate);
3655 if (PyErr_Occurred()) SWIG_fail;
3656 }
3657 {
3658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3659 }
3660 return resultobj;
3661 fail:
3662 return NULL;
3663 }
3664
3665
3666 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3667 PyObject *resultobj = NULL;
3668 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3669 wxControl *result;
3670 PyObject * obj0 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "self", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3677 if (SWIG_arg_fail(1)) SWIG_fail;
3678 {
3679 PyThreadState* __tstate = wxPyBeginAllowThreads();
3680 result = (wxControl *)(arg1)->GetControl();
3681
3682 wxPyEndAllowThreads(__tstate);
3683 if (PyErr_Occurred()) SWIG_fail;
3684 }
3685 {
3686 resultobj = wxPyMake_wxObject(result, 0);
3687 }
3688 return resultobj;
3689 fail:
3690 return NULL;
3691 }
3692
3693
3694 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3695 PyObject *resultobj = NULL;
3696 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3697 wxControl *arg2 = (wxControl *) 0 ;
3698 PyObject * obj0 = 0 ;
3699 PyObject * obj1 = 0 ;
3700 char *kwnames[] = {
3701 (char *) "self",(char *) "control", NULL
3702 };
3703
3704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3706 if (SWIG_arg_fail(1)) SWIG_fail;
3707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3708 if (SWIG_arg_fail(2)) SWIG_fail;
3709 {
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 (arg1)->SetControl(arg2);
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 Py_INCREF(Py_None); resultobj = Py_None;
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj = NULL;
3725 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3726 wxGridCellAttr *result;
3727 PyObject * obj0 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 PyThreadState* __tstate = wxPyBeginAllowThreads();
3737 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3738
3739 wxPyEndAllowThreads(__tstate);
3740 if (PyErr_Occurred()) SWIG_fail;
3741 }
3742 {
3743 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
3744 }
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj = NULL;
3753 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3754 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3755 PyObject * obj0 = 0 ;
3756 PyObject * obj1 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "self",(char *) "attr", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3763 if (SWIG_arg_fail(1)) SWIG_fail;
3764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(2)) SWIG_fail;
3766 {
3767 PyThreadState* __tstate = wxPyBeginAllowThreads();
3768 (arg1)->SetCellAttr(arg2);
3769
3770 wxPyEndAllowThreads(__tstate);
3771 if (PyErr_Occurred()) SWIG_fail;
3772 }
3773 Py_INCREF(Py_None); resultobj = Py_None;
3774 return resultobj;
3775 fail:
3776 return NULL;
3777 }
3778
3779
3780 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3781 PyObject *resultobj = NULL;
3782 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3783 wxString *arg2 = 0 ;
3784 bool temp2 = false ;
3785 PyObject * obj0 = 0 ;
3786 PyObject * obj1 = 0 ;
3787 char *kwnames[] = {
3788 (char *) "self",(char *) "params", NULL
3789 };
3790
3791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3793 if (SWIG_arg_fail(1)) SWIG_fail;
3794 {
3795 arg2 = wxString_in_helper(obj1);
3796 if (arg2 == NULL) SWIG_fail;
3797 temp2 = true;
3798 }
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 (arg1)->SetParameters((wxString const &)*arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 {
3808 if (temp2)
3809 delete arg2;
3810 }
3811 return resultobj;
3812 fail:
3813 {
3814 if (temp2)
3815 delete arg2;
3816 }
3817 return NULL;
3818 }
3819
3820
3821 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3822 PyObject *resultobj = NULL;
3823 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3824 PyObject * obj0 = 0 ;
3825 char *kwnames[] = {
3826 (char *) "self", NULL
3827 };
3828
3829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3831 if (SWIG_arg_fail(1)) SWIG_fail;
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 (arg1)->IncRef();
3835
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 Py_INCREF(Py_None); resultobj = Py_None;
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj = NULL;
3848 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3849 PyObject * obj0 = 0 ;
3850 char *kwnames[] = {
3851 (char *) "self", NULL
3852 };
3853
3854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3856 if (SWIG_arg_fail(1)) SWIG_fail;
3857 {
3858 PyThreadState* __tstate = wxPyBeginAllowThreads();
3859 (arg1)->DecRef();
3860
3861 wxPyEndAllowThreads(__tstate);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 Py_INCREF(Py_None); resultobj = Py_None;
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj = NULL;
3873 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3874 wxWindow *arg2 = (wxWindow *) 0 ;
3875 int arg3 ;
3876 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3877 PyObject * obj0 = 0 ;
3878 PyObject * obj1 = 0 ;
3879 PyObject * obj2 = 0 ;
3880 PyObject * obj3 = 0 ;
3881 char *kwnames[] = {
3882 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3883 };
3884
3885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3887 if (SWIG_arg_fail(1)) SWIG_fail;
3888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3889 if (SWIG_arg_fail(2)) SWIG_fail;
3890 {
3891 arg3 = static_cast<int >(SWIG_As_int(obj2));
3892 if (SWIG_arg_fail(3)) SWIG_fail;
3893 }
3894 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3895 if (SWIG_arg_fail(4)) SWIG_fail;
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 (arg1)->Create(arg2,arg3,arg4);
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_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj = NULL;
3912 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3913 int arg2 ;
3914 int arg3 ;
3915 wxGrid *arg4 = (wxGrid *) 0 ;
3916 PyObject * obj0 = 0 ;
3917 PyObject * obj1 = 0 ;
3918 PyObject * obj2 = 0 ;
3919 PyObject * obj3 = 0 ;
3920 char *kwnames[] = {
3921 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3922 };
3923
3924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3926 if (SWIG_arg_fail(1)) SWIG_fail;
3927 {
3928 arg2 = static_cast<int >(SWIG_As_int(obj1));
3929 if (SWIG_arg_fail(2)) SWIG_fail;
3930 }
3931 {
3932 arg3 = static_cast<int >(SWIG_As_int(obj2));
3933 if (SWIG_arg_fail(3)) SWIG_fail;
3934 }
3935 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(4)) SWIG_fail;
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 (arg1)->BeginEdit(arg2,arg3,arg4);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 Py_INCREF(Py_None); resultobj = Py_None;
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj = NULL;
3953 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3954 int arg2 ;
3955 int arg3 ;
3956 wxGrid *arg4 = (wxGrid *) 0 ;
3957 bool result;
3958 PyObject * obj0 = 0 ;
3959 PyObject * obj1 = 0 ;
3960 PyObject * obj2 = 0 ;
3961 PyObject * obj3 = 0 ;
3962 char *kwnames[] = {
3963 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3964 };
3965
3966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3968 if (SWIG_arg_fail(1)) SWIG_fail;
3969 {
3970 arg2 = static_cast<int >(SWIG_As_int(obj1));
3971 if (SWIG_arg_fail(2)) SWIG_fail;
3972 }
3973 {
3974 arg3 = static_cast<int >(SWIG_As_int(obj2));
3975 if (SWIG_arg_fail(3)) SWIG_fail;
3976 }
3977 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3978 if (SWIG_arg_fail(4)) SWIG_fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 {
3987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3988 }
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj = NULL;
3997 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3998 PyObject * obj0 = 0 ;
3999 char *kwnames[] = {
4000 (char *) "self", NULL
4001 };
4002
4003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
4004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4005 if (SWIG_arg_fail(1)) SWIG_fail;
4006 {
4007 PyThreadState* __tstate = wxPyBeginAllowThreads();
4008 (arg1)->Reset();
4009
4010 wxPyEndAllowThreads(__tstate);
4011 if (PyErr_Occurred()) SWIG_fail;
4012 }
4013 Py_INCREF(Py_None); resultobj = Py_None;
4014 return resultobj;
4015 fail:
4016 return NULL;
4017 }
4018
4019
4020 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
4021 PyObject *resultobj = NULL;
4022 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4023 wxGridCellEditor *result;
4024 PyObject * obj0 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "self", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
4030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4031 if (SWIG_arg_fail(1)) SWIG_fail;
4032 {
4033 PyThreadState* __tstate = wxPyBeginAllowThreads();
4034 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4035
4036 wxPyEndAllowThreads(__tstate);
4037 if (PyErr_Occurred()) SWIG_fail;
4038 }
4039 {
4040 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4041 }
4042 return resultobj;
4043 fail:
4044 return NULL;
4045 }
4046
4047
4048 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4049 PyObject *resultobj = NULL;
4050 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4051 wxRect *arg2 = 0 ;
4052 wxRect temp2 ;
4053 PyObject * obj0 = 0 ;
4054 PyObject * obj1 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "self",(char *) "rect", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
4060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4061 if (SWIG_arg_fail(1)) SWIG_fail;
4062 {
4063 arg2 = &temp2;
4064 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4065 }
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 (arg1)->SetSize((wxRect const &)*arg2);
4069
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 Py_INCREF(Py_None); resultobj = Py_None;
4074 return resultobj;
4075 fail:
4076 return NULL;
4077 }
4078
4079
4080 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj = NULL;
4082 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4083 bool arg2 ;
4084 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4085 PyObject * obj0 = 0 ;
4086 PyObject * obj1 = 0 ;
4087 PyObject * obj2 = 0 ;
4088 char *kwnames[] = {
4089 (char *) "self",(char *) "show",(char *) "attr", NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4094 if (SWIG_arg_fail(1)) SWIG_fail;
4095 {
4096 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
4097 if (SWIG_arg_fail(2)) SWIG_fail;
4098 }
4099 if (obj2) {
4100 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4101 if (SWIG_arg_fail(3)) SWIG_fail;
4102 }
4103 {
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 (arg1)->Show(arg2,arg3);
4106
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 Py_INCREF(Py_None); resultobj = Py_None;
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj = NULL;
4119 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4120 wxRect *arg2 = 0 ;
4121 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4122 wxRect temp2 ;
4123 PyObject * obj0 = 0 ;
4124 PyObject * obj1 = 0 ;
4125 PyObject * obj2 = 0 ;
4126 char *kwnames[] = {
4127 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4128 };
4129
4130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4132 if (SWIG_arg_fail(1)) SWIG_fail;
4133 {
4134 arg2 = &temp2;
4135 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4136 }
4137 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4138 if (SWIG_arg_fail(3)) SWIG_fail;
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
4142
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 Py_INCREF(Py_None); resultobj = Py_None;
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj = NULL;
4155 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4156 wxKeyEvent *arg2 = 0 ;
4157 bool result;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char *kwnames[] = {
4161 (char *) "self",(char *) "event", NULL
4162 };
4163
4164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4166 if (SWIG_arg_fail(1)) SWIG_fail;
4167 {
4168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4169 if (SWIG_arg_fail(2)) SWIG_fail;
4170 if (arg2 == NULL) {
4171 SWIG_null_ref("wxKeyEvent");
4172 }
4173 if (SWIG_arg_fail(2)) SWIG_fail;
4174 }
4175 {
4176 PyThreadState* __tstate = wxPyBeginAllowThreads();
4177 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4178
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 {
4183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4184 }
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = NULL;
4193 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4194 wxKeyEvent *arg2 = 0 ;
4195 PyObject * obj0 = 0 ;
4196 PyObject * obj1 = 0 ;
4197 char *kwnames[] = {
4198 (char *) "self",(char *) "event", NULL
4199 };
4200
4201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4203 if (SWIG_arg_fail(1)) SWIG_fail;
4204 {
4205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4206 if (SWIG_arg_fail(2)) SWIG_fail;
4207 if (arg2 == NULL) {
4208 SWIG_null_ref("wxKeyEvent");
4209 }
4210 if (SWIG_arg_fail(2)) SWIG_fail;
4211 }
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 (arg1)->StartingKey(*arg2);
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 Py_INCREF(Py_None); resultobj = Py_None;
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj = NULL;
4228 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4229 PyObject * obj0 = 0 ;
4230 char *kwnames[] = {
4231 (char *) "self", NULL
4232 };
4233
4234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4236 if (SWIG_arg_fail(1)) SWIG_fail;
4237 {
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 (arg1)->StartingClick();
4240
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 Py_INCREF(Py_None); resultobj = Py_None;
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj = NULL;
4253 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4254 wxKeyEvent *arg2 = 0 ;
4255 PyObject * obj0 = 0 ;
4256 PyObject * obj1 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self",(char *) "event", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4266 if (SWIG_arg_fail(2)) SWIG_fail;
4267 if (arg2 == NULL) {
4268 SWIG_null_ref("wxKeyEvent");
4269 }
4270 if (SWIG_arg_fail(2)) SWIG_fail;
4271 }
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 (arg1)->HandleReturn(*arg2);
4275
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 Py_INCREF(Py_None); resultobj = Py_None;
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4287 PyObject *resultobj = NULL;
4288 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4289 PyObject * obj0 = 0 ;
4290 char *kwnames[] = {
4291 (char *) "self", NULL
4292 };
4293
4294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4296 if (SWIG_arg_fail(1)) SWIG_fail;
4297 {
4298 PyThreadState* __tstate = wxPyBeginAllowThreads();
4299 (arg1)->Destroy();
4300
4301 wxPyEndAllowThreads(__tstate);
4302 if (PyErr_Occurred()) SWIG_fail;
4303 }
4304 Py_INCREF(Py_None); resultobj = Py_None;
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 static PyObject * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4312 PyObject *obj;
4313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4314 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4315 Py_INCREF(obj);
4316 return Py_BuildValue((char *)"");
4317 }
4318 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj = NULL;
4320 wxPyGridCellEditor *result;
4321 char *kwnames[] = {
4322 NULL
4323 };
4324
4325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4329
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj = NULL;
4342 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4343 PyObject *arg2 = (PyObject *) 0 ;
4344 PyObject *arg3 = (PyObject *) 0 ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 PyObject * obj2 = 0 ;
4348 char *kwnames[] = {
4349 (char *) "self",(char *) "self",(char *) "_class", NULL
4350 };
4351
4352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4354 if (SWIG_arg_fail(1)) SWIG_fail;
4355 arg2 = obj1;
4356 arg3 = obj2;
4357 {
4358 PyThreadState* __tstate = wxPyBeginAllowThreads();
4359 (arg1)->_setCallbackInfo(arg2,arg3);
4360
4361 wxPyEndAllowThreads(__tstate);
4362 if (PyErr_Occurred()) SWIG_fail;
4363 }
4364 Py_INCREF(Py_None); resultobj = Py_None;
4365 return resultobj;
4366 fail:
4367 return NULL;
4368 }
4369
4370
4371 static PyObject *_wrap_PyGridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4372 PyObject *resultobj = NULL;
4373 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4374 wxRect *arg2 = 0 ;
4375 wxRect temp2 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char *kwnames[] = {
4379 (char *) "self",(char *) "rect", NULL
4380 };
4381
4382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
4383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4384 if (SWIG_arg_fail(1)) SWIG_fail;
4385 {
4386 arg2 = &temp2;
4387 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4388 }
4389 {
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 (arg1)->SetSize((wxRect const &)*arg2);
4392
4393 wxPyEndAllowThreads(__tstate);
4394 if (PyErr_Occurred()) SWIG_fail;
4395 }
4396 Py_INCREF(Py_None); resultobj = Py_None;
4397 return resultobj;
4398 fail:
4399 return NULL;
4400 }
4401
4402
4403 static PyObject *_wrap_PyGridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4404 PyObject *resultobj = NULL;
4405 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4406 bool arg2 ;
4407 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4408 PyObject * obj0 = 0 ;
4409 PyObject * obj1 = 0 ;
4410 PyObject * obj2 = 0 ;
4411 char *kwnames[] = {
4412 (char *) "self",(char *) "show",(char *) "attr", NULL
4413 };
4414
4415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4417 if (SWIG_arg_fail(1)) SWIG_fail;
4418 {
4419 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
4420 if (SWIG_arg_fail(2)) SWIG_fail;
4421 }
4422 if (obj2) {
4423 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4424 if (SWIG_arg_fail(3)) SWIG_fail;
4425 }
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 (arg1)->Show(arg2,arg3);
4429
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 Py_INCREF(Py_None); resultobj = Py_None;
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 static PyObject *_wrap_PyGridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj = NULL;
4442 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4443 wxRect *arg2 = 0 ;
4444 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4445 wxRect temp2 ;
4446 PyObject * obj0 = 0 ;
4447 PyObject * obj1 = 0 ;
4448 PyObject * obj2 = 0 ;
4449 char *kwnames[] = {
4450 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4451 };
4452
4453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4455 if (SWIG_arg_fail(1)) SWIG_fail;
4456 {
4457 arg2 = &temp2;
4458 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4459 }
4460 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(3)) SWIG_fail;
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
4465
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 Py_INCREF(Py_None); resultobj = Py_None;
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 static PyObject *_wrap_PyGridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4477 PyObject *resultobj = NULL;
4478 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4479 wxKeyEvent *arg2 = 0 ;
4480 bool result;
4481 PyObject * obj0 = 0 ;
4482 PyObject * obj1 = 0 ;
4483 char *kwnames[] = {
4484 (char *) "self",(char *) "event", NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4489 if (SWIG_arg_fail(1)) SWIG_fail;
4490 {
4491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4492 if (SWIG_arg_fail(2)) SWIG_fail;
4493 if (arg2 == NULL) {
4494 SWIG_null_ref("wxKeyEvent");
4495 }
4496 if (SWIG_arg_fail(2)) SWIG_fail;
4497 }
4498 {
4499 PyThreadState* __tstate = wxPyBeginAllowThreads();
4500 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4501
4502 wxPyEndAllowThreads(__tstate);
4503 if (PyErr_Occurred()) SWIG_fail;
4504 }
4505 {
4506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4507 }
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 static PyObject *_wrap_PyGridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4515 PyObject *resultobj = NULL;
4516 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4517 wxKeyEvent *arg2 = 0 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char *kwnames[] = {
4521 (char *) "self",(char *) "event", NULL
4522 };
4523
4524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(1)) SWIG_fail;
4527 {
4528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4529 if (SWIG_arg_fail(2)) SWIG_fail;
4530 if (arg2 == NULL) {
4531 SWIG_null_ref("wxKeyEvent");
4532 }
4533 if (SWIG_arg_fail(2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 (arg1)->StartingKey(*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 Py_INCREF(Py_None); resultobj = Py_None;
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_PyGridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj = NULL;
4551 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4552 PyObject * obj0 = 0 ;
4553 char *kwnames[] = {
4554 (char *) "self", NULL
4555 };
4556
4557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4559 if (SWIG_arg_fail(1)) SWIG_fail;
4560 {
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 (arg1)->StartingClick();
4563
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 Py_INCREF(Py_None); resultobj = Py_None;
4568 return resultobj;
4569 fail:
4570 return NULL;
4571 }
4572
4573
4574 static PyObject *_wrap_PyGridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4575 PyObject *resultobj = NULL;
4576 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4577 wxKeyEvent *arg2 = 0 ;
4578 PyObject * obj0 = 0 ;
4579 PyObject * obj1 = 0 ;
4580 char *kwnames[] = {
4581 (char *) "self",(char *) "event", NULL
4582 };
4583
4584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4586 if (SWIG_arg_fail(1)) SWIG_fail;
4587 {
4588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4589 if (SWIG_arg_fail(2)) SWIG_fail;
4590 if (arg2 == NULL) {
4591 SWIG_null_ref("wxKeyEvent");
4592 }
4593 if (SWIG_arg_fail(2)) SWIG_fail;
4594 }
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 (arg1)->HandleReturn(*arg2);
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 Py_INCREF(Py_None); resultobj = Py_None;
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_PyGridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj = NULL;
4611 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4612 PyObject * obj0 = 0 ;
4613 char *kwnames[] = {
4614 (char *) "self", NULL
4615 };
4616
4617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(1)) SWIG_fail;
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 (arg1)->Destroy();
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 Py_INCREF(Py_None); resultobj = Py_None;
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 static PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj = NULL;
4636 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4637 wxString *arg2 = 0 ;
4638 bool temp2 = false ;
4639 PyObject * obj0 = 0 ;
4640 PyObject * obj1 = 0 ;
4641 char *kwnames[] = {
4642 (char *) "self",(char *) "params", NULL
4643 };
4644
4645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
4646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4647 if (SWIG_arg_fail(1)) SWIG_fail;
4648 {
4649 arg2 = wxString_in_helper(obj1);
4650 if (arg2 == NULL) SWIG_fail;
4651 temp2 = true;
4652 }
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 (arg1)->SetParameters((wxString const &)*arg2);
4656
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 Py_INCREF(Py_None); resultobj = Py_None;
4661 {
4662 if (temp2)
4663 delete arg2;
4664 }
4665 return resultobj;
4666 fail:
4667 {
4668 if (temp2)
4669 delete arg2;
4670 }
4671 return NULL;
4672 }
4673
4674
4675 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4676 PyObject *obj;
4677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4678 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4679 Py_INCREF(obj);
4680 return Py_BuildValue((char *)"");
4681 }
4682 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj = NULL;
4684 wxGridCellTextEditor *result;
4685 char *kwnames[] = {
4686 NULL
4687 };
4688
4689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = NULL;
4706 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4707 wxString result;
4708 PyObject * obj0 = 0 ;
4709 char *kwnames[] = {
4710 (char *) "self", NULL
4711 };
4712
4713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4715 if (SWIG_arg_fail(1)) SWIG_fail;
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (arg1)->GetValue();
4719
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 {
4724 #if wxUSE_UNICODE
4725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4726 #else
4727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4728 #endif
4729 }
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4737 PyObject *obj;
4738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4739 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4740 Py_INCREF(obj);
4741 return Py_BuildValue((char *)"");
4742 }
4743 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj = NULL;
4745 int arg1 = (int) -1 ;
4746 int arg2 = (int) -1 ;
4747 wxGridCellNumberEditor *result;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char *kwnames[] = {
4751 (char *) "min",(char *) "max", NULL
4752 };
4753
4754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4755 if (obj0) {
4756 {
4757 arg1 = static_cast<int >(SWIG_As_int(obj0));
4758 if (SWIG_arg_fail(1)) SWIG_fail;
4759 }
4760 }
4761 if (obj1) {
4762 {
4763 arg2 = static_cast<int >(SWIG_As_int(obj1));
4764 if (SWIG_arg_fail(2)) SWIG_fail;
4765 }
4766 }
4767 {
4768 PyThreadState* __tstate = wxPyBeginAllowThreads();
4769 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4770
4771 wxPyEndAllowThreads(__tstate);
4772 if (PyErr_Occurred()) SWIG_fail;
4773 }
4774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4775 return resultobj;
4776 fail:
4777 return NULL;
4778 }
4779
4780
4781 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4782 PyObject *resultobj = NULL;
4783 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4784 wxString result;
4785 PyObject * obj0 = 0 ;
4786 char *kwnames[] = {
4787 (char *) "self", NULL
4788 };
4789
4790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4792 if (SWIG_arg_fail(1)) SWIG_fail;
4793 {
4794 PyThreadState* __tstate = wxPyBeginAllowThreads();
4795 result = (arg1)->GetValue();
4796
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 {
4801 #if wxUSE_UNICODE
4802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4803 #else
4804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4805 #endif
4806 }
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4814 PyObject *obj;
4815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4816 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4817 Py_INCREF(obj);
4818 return Py_BuildValue((char *)"");
4819 }
4820 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj = NULL;
4822 int arg1 = (int) -1 ;
4823 int arg2 = (int) -1 ;
4824 wxGridCellFloatEditor *result;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "width",(char *) "precision", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4832 if (obj0) {
4833 {
4834 arg1 = static_cast<int >(SWIG_As_int(obj0));
4835 if (SWIG_arg_fail(1)) SWIG_fail;
4836 }
4837 }
4838 if (obj1) {
4839 {
4840 arg2 = static_cast<int >(SWIG_As_int(obj1));
4841 if (SWIG_arg_fail(2)) SWIG_fail;
4842 }
4843 }
4844 {
4845 PyThreadState* __tstate = wxPyBeginAllowThreads();
4846 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4847
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj = NULL;
4860 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4861 wxString result;
4862 PyObject * obj0 = 0 ;
4863 char *kwnames[] = {
4864 (char *) "self", NULL
4865 };
4866
4867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4869 if (SWIG_arg_fail(1)) SWIG_fail;
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (arg1)->GetValue();
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 {
4878 #if wxUSE_UNICODE
4879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4880 #else
4881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4882 #endif
4883 }
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4891 PyObject *obj;
4892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4893 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4894 Py_INCREF(obj);
4895 return Py_BuildValue((char *)"");
4896 }
4897 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = NULL;
4899 wxGridCellBoolEditor *result;
4900 char *kwnames[] = {
4901 NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4908
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = NULL;
4921 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4922 wxString result;
4923 PyObject * obj0 = 0 ;
4924 char *kwnames[] = {
4925 (char *) "self", NULL
4926 };
4927
4928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4930 if (SWIG_arg_fail(1)) SWIG_fail;
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 result = (arg1)->GetValue();
4934
4935 wxPyEndAllowThreads(__tstate);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 {
4939 #if wxUSE_UNICODE
4940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4941 #else
4942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4943 #endif
4944 }
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
4952 PyObject *obj;
4953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4954 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
4955 Py_INCREF(obj);
4956 return Py_BuildValue((char *)"");
4957 }
4958 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4959 PyObject *resultobj = NULL;
4960 int arg1 = (int) 0 ;
4961 wxString *arg2 = (wxString *) NULL ;
4962 bool arg3 = (bool) false ;
4963 wxGridCellChoiceEditor *result;
4964 PyObject * obj0 = 0 ;
4965 PyObject * obj1 = 0 ;
4966 char *kwnames[] = {
4967 (char *) "choices",(char *) "allowOthers", NULL
4968 };
4969
4970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
4971 if (obj0) {
4972 {
4973 arg1 = PyList_Size(obj0);
4974 arg2 = wxString_LIST_helper(obj0);
4975 if (arg2 == NULL) SWIG_fail;
4976 }
4977 }
4978 if (obj1) {
4979 {
4980 arg3 = static_cast<bool >(SWIG_As_bool(obj1));
4981 if (SWIG_arg_fail(3)) SWIG_fail;
4982 }
4983 }
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
4987
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
4992 {
4993 if (arg2) delete [] arg2;
4994 }
4995 return resultobj;
4996 fail:
4997 {
4998 if (arg2) delete [] arg2;
4999 }
5000 return NULL;
5001 }
5002
5003
5004 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj = NULL;
5006 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5007 wxString result;
5008 PyObject * obj0 = 0 ;
5009 char *kwnames[] = {
5010 (char *) "self", NULL
5011 };
5012
5013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
5014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
5015 if (SWIG_arg_fail(1)) SWIG_fail;
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 result = (arg1)->GetValue();
5019
5020 wxPyEndAllowThreads(__tstate);
5021 if (PyErr_Occurred()) SWIG_fail;
5022 }
5023 {
5024 #if wxUSE_UNICODE
5025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5026 #else
5027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5028 #endif
5029 }
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
5037 PyObject *obj;
5038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5039 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
5040 Py_INCREF(obj);
5041 return Py_BuildValue((char *)"");
5042 }
5043 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = NULL;
5045 wxString const &arg1_defvalue = wxPyEmptyString ;
5046 wxString *arg1 = (wxString *) &arg1_defvalue ;
5047 wxGridCellEnumEditor *result;
5048 bool temp1 = false ;
5049 PyObject * obj0 = 0 ;
5050 char *kwnames[] = {
5051 (char *) "choices", NULL
5052 };
5053
5054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
5055 if (obj0) {
5056 {
5057 arg1 = wxString_in_helper(obj0);
5058 if (arg1 == NULL) SWIG_fail;
5059 temp1 = true;
5060 }
5061 }
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5065
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
5070 {
5071 if (temp1)
5072 delete arg1;
5073 }
5074 return resultobj;
5075 fail:
5076 {
5077 if (temp1)
5078 delete arg1;
5079 }
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj = NULL;
5086 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
5087 wxString result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (arg1)->GetValue();
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 #if wxUSE_UNICODE
5105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5106 #else
5107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5108 #endif
5109 }
5110 return resultobj;
5111 fail:
5112 return NULL;
5113 }
5114
5115
5116 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
5117 PyObject *obj;
5118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5119 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
5120 Py_INCREF(obj);
5121 return Py_BuildValue((char *)"");
5122 }
5123 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj = NULL;
5125 wxGridCellAutoWrapStringEditor *result;
5126 char *kwnames[] = {
5127 NULL
5128 };
5129
5130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
5131 {
5132 PyThreadState* __tstate = wxPyBeginAllowThreads();
5133 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5134
5135 wxPyEndAllowThreads(__tstate);
5136 if (PyErr_Occurred()) SWIG_fail;
5137 }
5138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
5139 return resultobj;
5140 fail:
5141 return NULL;
5142 }
5143
5144
5145 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5146 PyObject *resultobj = NULL;
5147 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
5148 wxString result;
5149 PyObject * obj0 = 0 ;
5150 char *kwnames[] = {
5151 (char *) "self", NULL
5152 };
5153
5154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
5155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
5156 if (SWIG_arg_fail(1)) SWIG_fail;
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 result = (arg1)->GetValue();
5160
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 {
5165 #if wxUSE_UNICODE
5166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5167 #else
5168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5169 #endif
5170 }
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5178 PyObject *obj;
5179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5180 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5181 Py_INCREF(obj);
5182 return Py_BuildValue((char *)"");
5183 }
5184 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = NULL;
5186 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5187 PyObject *arg2 = (PyObject *) 0 ;
5188 PyObject * obj0 = 0 ;
5189 PyObject * obj1 = 0 ;
5190 char *kwnames[] = {
5191 (char *) "self",(char *) "_self", NULL
5192 };
5193
5194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5196 if (SWIG_arg_fail(1)) SWIG_fail;
5197 arg2 = obj1;
5198 {
5199 PyThreadState* __tstate = wxPyBeginAllowThreads();
5200 wxGridCellAttr__setOORInfo(arg1,arg2);
5201
5202 wxPyEndAllowThreads(__tstate);
5203 if (PyErr_Occurred()) SWIG_fail;
5204 }
5205 Py_INCREF(Py_None); resultobj = Py_None;
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5213 PyObject *resultobj = NULL;
5214 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5215 wxGridCellAttr *result;
5216 PyObject * obj0 = 0 ;
5217 char *kwnames[] = {
5218 (char *) "attrDefault", NULL
5219 };
5220
5221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5222 if (obj0) {
5223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5224 if (SWIG_arg_fail(1)) SWIG_fail;
5225 }
5226 {
5227 PyThreadState* __tstate = wxPyBeginAllowThreads();
5228 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5229
5230 wxPyEndAllowThreads(__tstate);
5231 if (PyErr_Occurred()) SWIG_fail;
5232 }
5233 {
5234 resultobj = wxPyMake_wxGridCellAttr(result, (bool)1);
5235 }
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = NULL;
5244 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5245 wxGridCellAttr *result;
5246 PyObject * obj0 = 0 ;
5247 char *kwnames[] = {
5248 (char *) "self", NULL
5249 };
5250
5251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5253 if (SWIG_arg_fail(1)) SWIG_fail;
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 {
5262 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5263 }
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5271 PyObject *resultobj = NULL;
5272 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5273 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5274 PyObject * obj0 = 0 ;
5275 PyObject * obj1 = 0 ;
5276 char *kwnames[] = {
5277 (char *) "self",(char *) "mergefrom", NULL
5278 };
5279
5280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5282 if (SWIG_arg_fail(1)) SWIG_fail;
5283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5284 if (SWIG_arg_fail(2)) SWIG_fail;
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 (arg1)->MergeWith(arg2);
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 Py_INCREF(Py_None); resultobj = Py_None;
5293 return resultobj;
5294 fail:
5295 return NULL;
5296 }
5297
5298
5299 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5300 PyObject *resultobj = NULL;
5301 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5302 PyObject * obj0 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5309 if (SWIG_arg_fail(1)) SWIG_fail;
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 (arg1)->IncRef();
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 Py_INCREF(Py_None); resultobj = Py_None;
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj = NULL;
5326 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5327 PyObject * obj0 = 0 ;
5328 char *kwnames[] = {
5329 (char *) "self", NULL
5330 };
5331
5332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5334 if (SWIG_arg_fail(1)) SWIG_fail;
5335 {
5336 PyThreadState* __tstate = wxPyBeginAllowThreads();
5337 (arg1)->DecRef();
5338
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 Py_INCREF(Py_None); resultobj = Py_None;
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = NULL;
5351 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5352 wxColour *arg2 = 0 ;
5353 wxColour temp2 ;
5354 PyObject * obj0 = 0 ;
5355 PyObject * obj1 = 0 ;
5356 char *kwnames[] = {
5357 (char *) "self",(char *) "colText", NULL
5358 };
5359
5360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5362 if (SWIG_arg_fail(1)) SWIG_fail;
5363 {
5364 arg2 = &temp2;
5365 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5366 }
5367 {
5368 PyThreadState* __tstate = wxPyBeginAllowThreads();
5369 (arg1)->SetTextColour((wxColour const &)*arg2);
5370
5371 wxPyEndAllowThreads(__tstate);
5372 if (PyErr_Occurred()) SWIG_fail;
5373 }
5374 Py_INCREF(Py_None); resultobj = Py_None;
5375 return resultobj;
5376 fail:
5377 return NULL;
5378 }
5379
5380
5381 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5382 PyObject *resultobj = NULL;
5383 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5384 wxColour *arg2 = 0 ;
5385 wxColour temp2 ;
5386 PyObject * obj0 = 0 ;
5387 PyObject * obj1 = 0 ;
5388 char *kwnames[] = {
5389 (char *) "self",(char *) "colBack", NULL
5390 };
5391
5392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5394 if (SWIG_arg_fail(1)) SWIG_fail;
5395 {
5396 arg2 = &temp2;
5397 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5398 }
5399 {
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
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_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj = NULL;
5415 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5416 wxFont *arg2 = 0 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self",(char *) "font", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 {
5427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5428 if (SWIG_arg_fail(2)) SWIG_fail;
5429 if (arg2 == NULL) {
5430 SWIG_null_ref("wxFont");
5431 }
5432 if (SWIG_arg_fail(2)) SWIG_fail;
5433 }
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 (arg1)->SetFont((wxFont const &)*arg2);
5437
5438 wxPyEndAllowThreads(__tstate);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 Py_INCREF(Py_None); resultobj = Py_None;
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj = NULL;
5450 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5451 int arg2 ;
5452 int arg3 ;
5453 PyObject * obj0 = 0 ;
5454 PyObject * obj1 = 0 ;
5455 PyObject * obj2 = 0 ;
5456 char *kwnames[] = {
5457 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5458 };
5459
5460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5462 if (SWIG_arg_fail(1)) SWIG_fail;
5463 {
5464 arg2 = static_cast<int >(SWIG_As_int(obj1));
5465 if (SWIG_arg_fail(2)) SWIG_fail;
5466 }
5467 {
5468 arg3 = static_cast<int >(SWIG_As_int(obj2));
5469 if (SWIG_arg_fail(3)) SWIG_fail;
5470 }
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 (arg1)->SetAlignment(arg2,arg3);
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 Py_INCREF(Py_None); resultobj = Py_None;
5479 return resultobj;
5480 fail:
5481 return NULL;
5482 }
5483
5484
5485 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5486 PyObject *resultobj = NULL;
5487 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5488 int arg2 ;
5489 int arg3 ;
5490 PyObject * obj0 = 0 ;
5491 PyObject * obj1 = 0 ;
5492 PyObject * obj2 = 0 ;
5493 char *kwnames[] = {
5494 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5495 };
5496
5497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5499 if (SWIG_arg_fail(1)) SWIG_fail;
5500 {
5501 arg2 = static_cast<int >(SWIG_As_int(obj1));
5502 if (SWIG_arg_fail(2)) SWIG_fail;
5503 }
5504 {
5505 arg3 = static_cast<int >(SWIG_As_int(obj2));
5506 if (SWIG_arg_fail(3)) SWIG_fail;
5507 }
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 (arg1)->SetSize(arg2,arg3);
5511
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 Py_INCREF(Py_None); resultobj = Py_None;
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = NULL;
5524 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5525 bool arg2 = (bool) true ;
5526 PyObject * obj0 = 0 ;
5527 PyObject * obj1 = 0 ;
5528 char *kwnames[] = {
5529 (char *) "self",(char *) "allow", NULL
5530 };
5531
5532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5534 if (SWIG_arg_fail(1)) SWIG_fail;
5535 if (obj1) {
5536 {
5537 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
5538 if (SWIG_arg_fail(2)) SWIG_fail;
5539 }
5540 }
5541 {
5542 PyThreadState* __tstate = wxPyBeginAllowThreads();
5543 (arg1)->SetOverflow(arg2);
5544
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 Py_INCREF(Py_None); resultobj = Py_None;
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj = NULL;
5557 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5558 bool arg2 = (bool) true ;
5559 PyObject * obj0 = 0 ;
5560 PyObject * obj1 = 0 ;
5561 char *kwnames[] = {
5562 (char *) "self",(char *) "isReadOnly", NULL
5563 };
5564
5565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5567 if (SWIG_arg_fail(1)) SWIG_fail;
5568 if (obj1) {
5569 {
5570 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
5571 if (SWIG_arg_fail(2)) SWIG_fail;
5572 }
5573 }
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 (arg1)->SetReadOnly(arg2);
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 Py_INCREF(Py_None); resultobj = Py_None;
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = NULL;
5590 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5591 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char *kwnames[] = {
5595 (char *) "self",(char *) "renderer", NULL
5596 };
5597
5598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5600 if (SWIG_arg_fail(1)) SWIG_fail;
5601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5602 if (SWIG_arg_fail(2)) SWIG_fail;
5603 {
5604 PyThreadState* __tstate = wxPyBeginAllowThreads();
5605 (arg1)->SetRenderer(arg2);
5606
5607 wxPyEndAllowThreads(__tstate);
5608 if (PyErr_Occurred()) SWIG_fail;
5609 }
5610 Py_INCREF(Py_None); resultobj = Py_None;
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj = NULL;
5619 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5620 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5621 PyObject * obj0 = 0 ;
5622 PyObject * obj1 = 0 ;
5623 char *kwnames[] = {
5624 (char *) "self",(char *) "editor", NULL
5625 };
5626
5627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5629 if (SWIG_arg_fail(1)) SWIG_fail;
5630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(2)) SWIG_fail;
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 (arg1)->SetEditor(arg2);
5635
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 Py_INCREF(Py_None); resultobj = Py_None;
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj = NULL;
5648 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5649 wxGridCellAttr::wxAttrKind arg2 ;
5650 PyObject * obj0 = 0 ;
5651 PyObject * obj1 = 0 ;
5652 char *kwnames[] = {
5653 (char *) "self",(char *) "kind", NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5658 if (SWIG_arg_fail(1)) SWIG_fail;
5659 {
5660 arg2 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj1));
5661 if (SWIG_arg_fail(2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 (arg1)->SetKind(arg2);
5666
5667 wxPyEndAllowThreads(__tstate);
5668 if (PyErr_Occurred()) SWIG_fail;
5669 }
5670 Py_INCREF(Py_None); resultobj = Py_None;
5671 return resultobj;
5672 fail:
5673 return NULL;
5674 }
5675
5676
5677 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5678 PyObject *resultobj = NULL;
5679 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5680 bool result;
5681 PyObject * obj0 = 0 ;
5682 char *kwnames[] = {
5683 (char *) "self", NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 {
5690 PyThreadState* __tstate = wxPyBeginAllowThreads();
5691 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5692
5693 wxPyEndAllowThreads(__tstate);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 {
5697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5698 }
5699 return resultobj;
5700 fail:
5701 return NULL;
5702 }
5703
5704
5705 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5706 PyObject *resultobj = NULL;
5707 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5708 bool result;
5709 PyObject * obj0 = 0 ;
5710 char *kwnames[] = {
5711 (char *) "self", NULL
5712 };
5713
5714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5716 if (SWIG_arg_fail(1)) SWIG_fail;
5717 {
5718 PyThreadState* __tstate = wxPyBeginAllowThreads();
5719 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5720
5721 wxPyEndAllowThreads(__tstate);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5726 }
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj = NULL;
5735 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5736 bool result;
5737 PyObject * obj0 = 0 ;
5738 char *kwnames[] = {
5739 (char *) "self", NULL
5740 };
5741
5742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5744 if (SWIG_arg_fail(1)) SWIG_fail;
5745 {
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 {
5753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5754 }
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj = NULL;
5763 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5764 bool result;
5765 PyObject * obj0 = 0 ;
5766 char *kwnames[] = {
5767 (char *) "self", NULL
5768 };
5769
5770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5772 if (SWIG_arg_fail(1)) SWIG_fail;
5773 {
5774 PyThreadState* __tstate = wxPyBeginAllowThreads();
5775 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5776
5777 wxPyEndAllowThreads(__tstate);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 {
5781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5782 }
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj = NULL;
5791 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5792 bool result;
5793 PyObject * obj0 = 0 ;
5794 char *kwnames[] = {
5795 (char *) "self", NULL
5796 };
5797
5798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5800 if (SWIG_arg_fail(1)) SWIG_fail;
5801 {
5802 PyThreadState* __tstate = wxPyBeginAllowThreads();
5803 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5804
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 {
5809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5810 }
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj = NULL;
5819 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5820 bool result;
5821 PyObject * obj0 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "self", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 {
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 {
5837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = NULL;
5847 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5848 bool result;
5849 PyObject * obj0 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "self", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 {
5858 PyThreadState* __tstate = wxPyBeginAllowThreads();
5859 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5860
5861 wxPyEndAllowThreads(__tstate);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 {
5865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5866 }
5867 return resultobj;
5868 fail:
5869 return NULL;
5870 }
5871
5872
5873 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj = NULL;
5875 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5876 bool result;
5877 PyObject * obj0 = 0 ;
5878 char *kwnames[] = {
5879 (char *) "self", NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5884 if (SWIG_arg_fail(1)) SWIG_fail;
5885 {
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 {
5893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5894 }
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = NULL;
5903 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5904 wxColour result;
5905 PyObject * obj0 = 0 ;
5906 char *kwnames[] = {
5907 (char *) "self", NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5912 if (SWIG_arg_fail(1)) SWIG_fail;
5913 {
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 {
5921 wxColour * resultptr;
5922 resultptr = new wxColour(static_cast<wxColour & >(result));
5923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5924 }
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj = NULL;
5933 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5934 wxColour result;
5935 PyObject * obj0 = 0 ;
5936 char *kwnames[] = {
5937 (char *) "self", NULL
5938 };
5939
5940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
5941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5942 if (SWIG_arg_fail(1)) SWIG_fail;
5943 {
5944 PyThreadState* __tstate = wxPyBeginAllowThreads();
5945 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
5946
5947 wxPyEndAllowThreads(__tstate);
5948 if (PyErr_Occurred()) SWIG_fail;
5949 }
5950 {
5951 wxColour * resultptr;
5952 resultptr = new wxColour(static_cast<wxColour & >(result));
5953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = NULL;
5963 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5964 wxFont result;
5965 PyObject * obj0 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "self", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
5971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5972 if (SWIG_arg_fail(1)) SWIG_fail;
5973 {
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 result = ((wxGridCellAttr const *)arg1)->GetFont();
5976
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 {
5981 wxFont * resultptr;
5982 resultptr = new wxFont(static_cast<wxFont & >(result));
5983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
5984 }
5985 return resultobj;
5986 fail:
5987 return NULL;
5988 }
5989
5990
5991 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj = NULL;
5993 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5994 int *arg2 = (int *) 0 ;
5995 int *arg3 = (int *) 0 ;
5996 int temp2 ;
5997 int res2 = 0 ;
5998 int temp3 ;
5999 int res3 = 0 ;
6000 PyObject * obj0 = 0 ;
6001 char *kwnames[] = {
6002 (char *) "self", NULL
6003 };
6004
6005 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6006 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
6008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6009 if (SWIG_arg_fail(1)) SWIG_fail;
6010 {
6011 PyThreadState* __tstate = wxPyBeginAllowThreads();
6012 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6013
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 Py_INCREF(Py_None); resultobj = Py_None;
6018 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6019 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6020 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6021 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj = NULL;
6030 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6031 int *arg2 = (int *) 0 ;
6032 int *arg3 = (int *) 0 ;
6033 int temp2 ;
6034 int res2 = 0 ;
6035 int temp3 ;
6036 int res3 = 0 ;
6037 PyObject * obj0 = 0 ;
6038 char *kwnames[] = {
6039 (char *) "self", NULL
6040 };
6041
6042 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6043 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
6045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6046 if (SWIG_arg_fail(1)) SWIG_fail;
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 Py_INCREF(Py_None); resultobj = Py_None;
6055 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6056 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6057 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6058 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj = NULL;
6067 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6068 bool result;
6069 PyObject * obj0 = 0 ;
6070 char *kwnames[] = {
6071 (char *) "self", NULL
6072 };
6073
6074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
6075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6076 if (SWIG_arg_fail(1)) SWIG_fail;
6077 {
6078 PyThreadState* __tstate = wxPyBeginAllowThreads();
6079 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6080
6081 wxPyEndAllowThreads(__tstate);
6082 if (PyErr_Occurred()) SWIG_fail;
6083 }
6084 {
6085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6086 }
6087 return resultobj;
6088 fail:
6089 return NULL;
6090 }
6091
6092
6093 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj = NULL;
6095 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6096 wxGrid *arg2 = (wxGrid *) 0 ;
6097 int arg3 ;
6098 int arg4 ;
6099 wxGridCellRenderer *result;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 PyObject * obj2 = 0 ;
6103 PyObject * obj3 = 0 ;
6104 char *kwnames[] = {
6105 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6106 };
6107
6108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6112 if (SWIG_arg_fail(2)) SWIG_fail;
6113 {
6114 arg3 = static_cast<int >(SWIG_As_int(obj2));
6115 if (SWIG_arg_fail(3)) SWIG_fail;
6116 }
6117 {
6118 arg4 = static_cast<int >(SWIG_As_int(obj3));
6119 if (SWIG_arg_fail(4)) SWIG_fail;
6120 }
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6130 }
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = NULL;
6139 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6140 wxGrid *arg2 = (wxGrid *) 0 ;
6141 int arg3 ;
6142 int arg4 ;
6143 wxGridCellEditor *result;
6144 PyObject * obj0 = 0 ;
6145 PyObject * obj1 = 0 ;
6146 PyObject * obj2 = 0 ;
6147 PyObject * obj3 = 0 ;
6148 char *kwnames[] = {
6149 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6150 };
6151
6152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6156 if (SWIG_arg_fail(2)) SWIG_fail;
6157 {
6158 arg3 = static_cast<int >(SWIG_As_int(obj2));
6159 if (SWIG_arg_fail(3)) SWIG_fail;
6160 }
6161 {
6162 arg4 = static_cast<int >(SWIG_As_int(obj3));
6163 if (SWIG_arg_fail(4)) SWIG_fail;
6164 }
6165 {
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6168
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 {
6173 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6174 }
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = NULL;
6183 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6184 bool result;
6185 PyObject * obj0 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 {
6201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6202 }
6203 return resultobj;
6204 fail:
6205 return NULL;
6206 }
6207
6208
6209 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6210 PyObject *resultobj = NULL;
6211 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6212 wxGridCellAttr::wxAttrKind result;
6213 PyObject * obj0 = 0 ;
6214 char *kwnames[] = {
6215 (char *) "self", NULL
6216 };
6217
6218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6220 if (SWIG_arg_fail(1)) SWIG_fail;
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6224
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_From_int((result));
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj = NULL;
6237 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6238 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "self",(char *) "defAttr", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6249 if (SWIG_arg_fail(2)) SWIG_fail;
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 (arg1)->SetDefAttr(arg2);
6253
6254 wxPyEndAllowThreads(__tstate);
6255 if (PyErr_Occurred()) SWIG_fail;
6256 }
6257 Py_INCREF(Py_None); resultobj = Py_None;
6258 return resultobj;
6259 fail:
6260 return NULL;
6261 }
6262
6263
6264 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6265 PyObject *obj;
6266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6267 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6268 Py_INCREF(obj);
6269 return Py_BuildValue((char *)"");
6270 }
6271 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj = NULL;
6273 wxGridCellAttrProvider *result;
6274 char *kwnames[] = {
6275 NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6279 {
6280 PyThreadState* __tstate = wxPyBeginAllowThreads();
6281 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6282
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)1);
6288 }
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj = NULL;
6297 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6298 PyObject *arg2 = (PyObject *) 0 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "self",(char *) "_self", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 arg2 = obj1;
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 Py_INCREF(Py_None); resultobj = Py_None;
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj = NULL;
6325 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6326 int arg2 ;
6327 int arg3 ;
6328 wxGridCellAttr::wxAttrKind arg4 ;
6329 wxGridCellAttr *result;
6330 PyObject * obj0 = 0 ;
6331 PyObject * obj1 = 0 ;
6332 PyObject * obj2 = 0 ;
6333 PyObject * obj3 = 0 ;
6334 char *kwnames[] = {
6335 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6336 };
6337
6338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6340 if (SWIG_arg_fail(1)) SWIG_fail;
6341 {
6342 arg2 = static_cast<int >(SWIG_As_int(obj1));
6343 if (SWIG_arg_fail(2)) SWIG_fail;
6344 }
6345 {
6346 arg3 = static_cast<int >(SWIG_As_int(obj2));
6347 if (SWIG_arg_fail(3)) SWIG_fail;
6348 }
6349 {
6350 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
6351 if (SWIG_arg_fail(4)) SWIG_fail;
6352 }
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
6356
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 {
6361 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj = NULL;
6371 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6372 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6373 int arg3 ;
6374 int arg4 ;
6375 PyObject * obj0 = 0 ;
6376 PyObject * obj1 = 0 ;
6377 PyObject * obj2 = 0 ;
6378 PyObject * obj3 = 0 ;
6379 char *kwnames[] = {
6380 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6381 };
6382
6383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6385 if (SWIG_arg_fail(1)) SWIG_fail;
6386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(2)) SWIG_fail;
6388 {
6389 arg3 = static_cast<int >(SWIG_As_int(obj2));
6390 if (SWIG_arg_fail(3)) SWIG_fail;
6391 }
6392 {
6393 arg4 = static_cast<int >(SWIG_As_int(obj3));
6394 if (SWIG_arg_fail(4)) SWIG_fail;
6395 }
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetAttr(arg2,arg3,arg4);
6399
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 Py_INCREF(Py_None); resultobj = Py_None;
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj = NULL;
6412 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6413 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6414 int arg3 ;
6415 PyObject * obj0 = 0 ;
6416 PyObject * obj1 = 0 ;
6417 PyObject * obj2 = 0 ;
6418 char *kwnames[] = {
6419 (char *) "self",(char *) "attr",(char *) "row", NULL
6420 };
6421
6422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6424 if (SWIG_arg_fail(1)) SWIG_fail;
6425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6426 if (SWIG_arg_fail(2)) SWIG_fail;
6427 {
6428 arg3 = static_cast<int >(SWIG_As_int(obj2));
6429 if (SWIG_arg_fail(3)) SWIG_fail;
6430 }
6431 {
6432 PyThreadState* __tstate = wxPyBeginAllowThreads();
6433 (arg1)->SetRowAttr(arg2,arg3);
6434
6435 wxPyEndAllowThreads(__tstate);
6436 if (PyErr_Occurred()) SWIG_fail;
6437 }
6438 Py_INCREF(Py_None); resultobj = Py_None;
6439 return resultobj;
6440 fail:
6441 return NULL;
6442 }
6443
6444
6445 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6446 PyObject *resultobj = NULL;
6447 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6448 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6449 int arg3 ;
6450 PyObject * obj0 = 0 ;
6451 PyObject * obj1 = 0 ;
6452 PyObject * obj2 = 0 ;
6453 char *kwnames[] = {
6454 (char *) "self",(char *) "attr",(char *) "col", NULL
6455 };
6456
6457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6459 if (SWIG_arg_fail(1)) SWIG_fail;
6460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6461 if (SWIG_arg_fail(2)) SWIG_fail;
6462 {
6463 arg3 = static_cast<int >(SWIG_As_int(obj2));
6464 if (SWIG_arg_fail(3)) SWIG_fail;
6465 }
6466 {
6467 PyThreadState* __tstate = wxPyBeginAllowThreads();
6468 (arg1)->SetColAttr(arg2,arg3);
6469
6470 wxPyEndAllowThreads(__tstate);
6471 if (PyErr_Occurred()) SWIG_fail;
6472 }
6473 Py_INCREF(Py_None); resultobj = Py_None;
6474 return resultobj;
6475 fail:
6476 return NULL;
6477 }
6478
6479
6480 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6481 PyObject *resultobj = NULL;
6482 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6483 size_t arg2 ;
6484 int arg3 ;
6485 PyObject * obj0 = 0 ;
6486 PyObject * obj1 = 0 ;
6487 PyObject * obj2 = 0 ;
6488 char *kwnames[] = {
6489 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6490 };
6491
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6494 if (SWIG_arg_fail(1)) SWIG_fail;
6495 {
6496 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
6497 if (SWIG_arg_fail(2)) SWIG_fail;
6498 }
6499 {
6500 arg3 = static_cast<int >(SWIG_As_int(obj2));
6501 if (SWIG_arg_fail(3)) SWIG_fail;
6502 }
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 (arg1)->UpdateAttrRows(arg2,arg3);
6506
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 Py_INCREF(Py_None); resultobj = Py_None;
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj = NULL;
6519 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6520 size_t arg2 ;
6521 int arg3 ;
6522 PyObject * obj0 = 0 ;
6523 PyObject * obj1 = 0 ;
6524 PyObject * obj2 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6531 if (SWIG_arg_fail(1)) SWIG_fail;
6532 {
6533 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
6534 if (SWIG_arg_fail(2)) SWIG_fail;
6535 }
6536 {
6537 arg3 = static_cast<int >(SWIG_As_int(obj2));
6538 if (SWIG_arg_fail(3)) SWIG_fail;
6539 }
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 (arg1)->UpdateAttrCols(arg2,arg3);
6543
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 Py_INCREF(Py_None); resultobj = Py_None;
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6555 PyObject *obj;
6556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6557 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6558 Py_INCREF(obj);
6559 return Py_BuildValue((char *)"");
6560 }
6561 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj = NULL;
6563 wxPyGridCellAttrProvider *result;
6564 char *kwnames[] = {
6565 NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6569 {
6570 PyThreadState* __tstate = wxPyBeginAllowThreads();
6571 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6572
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6584 PyObject *resultobj = NULL;
6585 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6586 PyObject *arg2 = (PyObject *) 0 ;
6587 PyObject *arg3 = (PyObject *) 0 ;
6588 PyObject * obj0 = 0 ;
6589 PyObject * obj1 = 0 ;
6590 PyObject * obj2 = 0 ;
6591 char *kwnames[] = {
6592 (char *) "self",(char *) "self",(char *) "_class", NULL
6593 };
6594
6595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6597 if (SWIG_arg_fail(1)) SWIG_fail;
6598 arg2 = obj1;
6599 arg3 = obj2;
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 (arg1)->_setCallbackInfo(arg2,arg3);
6603
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 Py_INCREF(Py_None); resultobj = Py_None;
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = NULL;
6616 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6617 int arg2 ;
6618 int arg3 ;
6619 wxGridCellAttr::wxAttrKind arg4 ;
6620 wxGridCellAttr *result;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 PyObject * obj2 = 0 ;
6624 PyObject * obj3 = 0 ;
6625 char *kwnames[] = {
6626 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6627 };
6628
6629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6631 if (SWIG_arg_fail(1)) SWIG_fail;
6632 {
6633 arg2 = static_cast<int >(SWIG_As_int(obj1));
6634 if (SWIG_arg_fail(2)) SWIG_fail;
6635 }
6636 {
6637 arg3 = static_cast<int >(SWIG_As_int(obj2));
6638 if (SWIG_arg_fail(3)) SWIG_fail;
6639 }
6640 {
6641 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
6642 if (SWIG_arg_fail(4)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
6647
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 {
6652 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6653 }
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj = NULL;
6662 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6663 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6664 int arg3 ;
6665 int arg4 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 PyObject * obj2 = 0 ;
6669 PyObject * obj3 = 0 ;
6670 char *kwnames[] = {
6671 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6672 };
6673
6674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6676 if (SWIG_arg_fail(1)) SWIG_fail;
6677 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(2)) SWIG_fail;
6679 {
6680 arg3 = static_cast<int >(SWIG_As_int(obj2));
6681 if (SWIG_arg_fail(3)) SWIG_fail;
6682 }
6683 {
6684 arg4 = static_cast<int >(SWIG_As_int(obj3));
6685 if (SWIG_arg_fail(4)) SWIG_fail;
6686 }
6687 {
6688 PyThreadState* __tstate = wxPyBeginAllowThreads();
6689 (arg1)->SetAttr(arg2,arg3,arg4);
6690
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 Py_INCREF(Py_None); resultobj = Py_None;
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 static PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6702 PyObject *resultobj = NULL;
6703 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6704 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6705 int arg3 ;
6706 PyObject * obj0 = 0 ;
6707 PyObject * obj1 = 0 ;
6708 PyObject * obj2 = 0 ;
6709 char *kwnames[] = {
6710 (char *) "self",(char *) "attr",(char *) "row", NULL
6711 };
6712
6713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6715 if (SWIG_arg_fail(1)) SWIG_fail;
6716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(2)) SWIG_fail;
6718 {
6719 arg3 = static_cast<int >(SWIG_As_int(obj2));
6720 if (SWIG_arg_fail(3)) SWIG_fail;
6721 }
6722 {
6723 PyThreadState* __tstate = wxPyBeginAllowThreads();
6724 (arg1)->SetRowAttr(arg2,arg3);
6725
6726 wxPyEndAllowThreads(__tstate);
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 Py_INCREF(Py_None); resultobj = Py_None;
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 static PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6737 PyObject *resultobj = NULL;
6738 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6739 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6740 int arg3 ;
6741 PyObject * obj0 = 0 ;
6742 PyObject * obj1 = 0 ;
6743 PyObject * obj2 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "attr",(char *) "col", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6752 if (SWIG_arg_fail(2)) SWIG_fail;
6753 {
6754 arg3 = static_cast<int >(SWIG_As_int(obj2));
6755 if (SWIG_arg_fail(3)) SWIG_fail;
6756 }
6757 {
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 (arg1)->SetColAttr(arg2,arg3);
6760
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 Py_INCREF(Py_None); resultobj = Py_None;
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6772 PyObject *obj;
6773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6774 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6775 Py_INCREF(obj);
6776 return Py_BuildValue((char *)"");
6777 }
6778 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj = NULL;
6780 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6781 PyObject *arg2 = (PyObject *) 0 ;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "_self", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 arg2 = obj1;
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 wxGridTableBase__setOORInfo(arg1,arg2);
6795
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 Py_INCREF(Py_None); resultobj = Py_None;
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = NULL;
6808 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6809 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "self",(char *) "attrProvider", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6820 if (SWIG_arg_fail(2)) SWIG_fail;
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 (arg1)->SetAttrProvider(arg2);
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 *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6836 PyObject *resultobj = NULL;
6837 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6838 wxGridCellAttrProvider *result;
6839 PyObject * obj0 = 0 ;
6840 char *kwnames[] = {
6841 (char *) "self", NULL
6842 };
6843
6844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6846 if (SWIG_arg_fail(1)) SWIG_fail;
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6850
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 {
6855 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj = NULL;
6865 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6866 wxGrid *arg2 = (wxGrid *) 0 ;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self",(char *) "grid", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6877 if (SWIG_arg_fail(2)) SWIG_fail;
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 (arg1)->SetView(arg2);
6881
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 Py_INCREF(Py_None); resultobj = Py_None;
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj = NULL;
6894 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6895 wxGrid *result;
6896 PyObject * obj0 = 0 ;
6897 char *kwnames[] = {
6898 (char *) "self", NULL
6899 };
6900
6901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6903 if (SWIG_arg_fail(1)) SWIG_fail;
6904 {
6905 PyThreadState* __tstate = wxPyBeginAllowThreads();
6906 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6907
6908 wxPyEndAllowThreads(__tstate);
6909 if (PyErr_Occurred()) SWIG_fail;
6910 }
6911 {
6912 resultobj = wxPyMake_wxObject(result, (bool)0);
6913 }
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = NULL;
6922 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6923 int result;
6924 PyObject * obj0 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "self", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = (int)(arg1)->GetNumberRows();
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 {
6940 resultobj = SWIG_From_int(static_cast<int >(result));
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj = NULL;
6950 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6951 int result;
6952 PyObject * obj0 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 result = (int)(arg1)->GetNumberCols();
6963
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 {
6968 resultobj = SWIG_From_int(static_cast<int >(result));
6969 }
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj = NULL;
6978 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6979 int arg2 ;
6980 int arg3 ;
6981 bool result;
6982 PyObject * obj0 = 0 ;
6983 PyObject * obj1 = 0 ;
6984 PyObject * obj2 = 0 ;
6985 char *kwnames[] = {
6986 (char *) "self",(char *) "row",(char *) "col", NULL
6987 };
6988
6989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
6990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6991 if (SWIG_arg_fail(1)) SWIG_fail;
6992 {
6993 arg2 = static_cast<int >(SWIG_As_int(obj1));
6994 if (SWIG_arg_fail(2)) SWIG_fail;
6995 }
6996 {
6997 arg3 = static_cast<int >(SWIG_As_int(obj2));
6998 if (SWIG_arg_fail(3)) SWIG_fail;
6999 }
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7003
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 {
7008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7009 }
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = NULL;
7018 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7019 int arg2 ;
7020 int arg3 ;
7021 wxString result;
7022 PyObject * obj0 = 0 ;
7023 PyObject * obj1 = 0 ;
7024 PyObject * obj2 = 0 ;
7025 char *kwnames[] = {
7026 (char *) "self",(char *) "row",(char *) "col", NULL
7027 };
7028
7029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7031 if (SWIG_arg_fail(1)) SWIG_fail;
7032 {
7033 arg2 = static_cast<int >(SWIG_As_int(obj1));
7034 if (SWIG_arg_fail(2)) SWIG_fail;
7035 }
7036 {
7037 arg3 = static_cast<int >(SWIG_As_int(obj2));
7038 if (SWIG_arg_fail(3)) SWIG_fail;
7039 }
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 result = (arg1)->GetValue(arg2,arg3);
7043
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 {
7048 #if wxUSE_UNICODE
7049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7050 #else
7051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7052 #endif
7053 }
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = NULL;
7062 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7063 int arg2 ;
7064 int arg3 ;
7065 wxString *arg4 = 0 ;
7066 bool temp4 = false ;
7067 PyObject * obj0 = 0 ;
7068 PyObject * obj1 = 0 ;
7069 PyObject * obj2 = 0 ;
7070 PyObject * obj3 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 arg2 = static_cast<int >(SWIG_As_int(obj1));
7080 if (SWIG_arg_fail(2)) SWIG_fail;
7081 }
7082 {
7083 arg3 = static_cast<int >(SWIG_As_int(obj2));
7084 if (SWIG_arg_fail(3)) SWIG_fail;
7085 }
7086 {
7087 arg4 = wxString_in_helper(obj3);
7088 if (arg4 == NULL) SWIG_fail;
7089 temp4 = true;
7090 }
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 Py_INCREF(Py_None); resultobj = Py_None;
7099 {
7100 if (temp4)
7101 delete arg4;
7102 }
7103 return resultobj;
7104 fail:
7105 {
7106 if (temp4)
7107 delete arg4;
7108 }
7109 return NULL;
7110 }
7111
7112
7113 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = NULL;
7115 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7116 int arg2 ;
7117 int arg3 ;
7118 wxString result;
7119 PyObject * obj0 = 0 ;
7120 PyObject * obj1 = 0 ;
7121 PyObject * obj2 = 0 ;
7122 char *kwnames[] = {
7123 (char *) "self",(char *) "row",(char *) "col", NULL
7124 };
7125
7126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
7127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7128 if (SWIG_arg_fail(1)) SWIG_fail;
7129 {
7130 arg2 = static_cast<int >(SWIG_As_int(obj1));
7131 if (SWIG_arg_fail(2)) SWIG_fail;
7132 }
7133 {
7134 arg3 = static_cast<int >(SWIG_As_int(obj2));
7135 if (SWIG_arg_fail(3)) SWIG_fail;
7136 }
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (arg1)->GetTypeName(arg2,arg3);
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 #if wxUSE_UNICODE
7146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7147 #else
7148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7149 #endif
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj = NULL;
7159 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7160 int arg2 ;
7161 int arg3 ;
7162 wxString *arg4 = 0 ;
7163 bool result;
7164 bool temp4 = false ;
7165 PyObject * obj0 = 0 ;
7166 PyObject * obj1 = 0 ;
7167 PyObject * obj2 = 0 ;
7168 PyObject * obj3 = 0 ;
7169 char *kwnames[] = {
7170 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7171 };
7172
7173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7175 if (SWIG_arg_fail(1)) SWIG_fail;
7176 {
7177 arg2 = static_cast<int >(SWIG_As_int(obj1));
7178 if (SWIG_arg_fail(2)) SWIG_fail;
7179 }
7180 {
7181 arg3 = static_cast<int >(SWIG_As_int(obj2));
7182 if (SWIG_arg_fail(3)) SWIG_fail;
7183 }
7184 {
7185 arg4 = wxString_in_helper(obj3);
7186 if (arg4 == NULL) SWIG_fail;
7187 temp4 = true;
7188 }
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7192
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 {
7197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7198 }
7199 {
7200 if (temp4)
7201 delete arg4;
7202 }
7203 return resultobj;
7204 fail:
7205 {
7206 if (temp4)
7207 delete arg4;
7208 }
7209 return NULL;
7210 }
7211
7212
7213 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7214 PyObject *resultobj = NULL;
7215 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7216 int arg2 ;
7217 int arg3 ;
7218 wxString *arg4 = 0 ;
7219 bool result;
7220 bool temp4 = false ;
7221 PyObject * obj0 = 0 ;
7222 PyObject * obj1 = 0 ;
7223 PyObject * obj2 = 0 ;
7224 PyObject * obj3 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 {
7233 arg2 = static_cast<int >(SWIG_As_int(obj1));
7234 if (SWIG_arg_fail(2)) SWIG_fail;
7235 }
7236 {
7237 arg3 = static_cast<int >(SWIG_As_int(obj2));
7238 if (SWIG_arg_fail(3)) SWIG_fail;
7239 }
7240 {
7241 arg4 = wxString_in_helper(obj3);
7242 if (arg4 == NULL) SWIG_fail;
7243 temp4 = true;
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 {
7253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7254 }
7255 {
7256 if (temp4)
7257 delete arg4;
7258 }
7259 return resultobj;
7260 fail:
7261 {
7262 if (temp4)
7263 delete arg4;
7264 }
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj = NULL;
7271 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7272 int arg2 ;
7273 int arg3 ;
7274 long result;
7275 PyObject * obj0 = 0 ;
7276 PyObject * obj1 = 0 ;
7277 PyObject * obj2 = 0 ;
7278 char *kwnames[] = {
7279 (char *) "self",(char *) "row",(char *) "col", NULL
7280 };
7281
7282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7284 if (SWIG_arg_fail(1)) SWIG_fail;
7285 {
7286 arg2 = static_cast<int >(SWIG_As_int(obj1));
7287 if (SWIG_arg_fail(2)) SWIG_fail;
7288 }
7289 {
7290 arg3 = static_cast<int >(SWIG_As_int(obj2));
7291 if (SWIG_arg_fail(3)) SWIG_fail;
7292 }
7293 {
7294 PyThreadState* __tstate = wxPyBeginAllowThreads();
7295 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7296
7297 wxPyEndAllowThreads(__tstate);
7298 if (PyErr_Occurred()) SWIG_fail;
7299 }
7300 {
7301 resultobj = SWIG_From_long(static_cast<long >(result));
7302 }
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj = NULL;
7311 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7312 int arg2 ;
7313 int arg3 ;
7314 double result;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 PyObject * obj2 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self",(char *) "row",(char *) "col", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 arg2 = static_cast<int >(SWIG_As_int(obj1));
7327 if (SWIG_arg_fail(2)) SWIG_fail;
7328 }
7329 {
7330 arg3 = static_cast<int >(SWIG_As_int(obj2));
7331 if (SWIG_arg_fail(3)) SWIG_fail;
7332 }
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7336
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 {
7341 resultobj = SWIG_From_double(static_cast<double >(result));
7342 }
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj = NULL;
7351 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7352 int arg2 ;
7353 int arg3 ;
7354 bool result;
7355 PyObject * obj0 = 0 ;
7356 PyObject * obj1 = 0 ;
7357 PyObject * obj2 = 0 ;
7358 char *kwnames[] = {
7359 (char *) "self",(char *) "row",(char *) "col", NULL
7360 };
7361
7362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7364 if (SWIG_arg_fail(1)) SWIG_fail;
7365 {
7366 arg2 = static_cast<int >(SWIG_As_int(obj1));
7367 if (SWIG_arg_fail(2)) SWIG_fail;
7368 }
7369 {
7370 arg3 = static_cast<int >(SWIG_As_int(obj2));
7371 if (SWIG_arg_fail(3)) SWIG_fail;
7372 }
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 {
7381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7382 }
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = NULL;
7391 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7392 int arg2 ;
7393 int arg3 ;
7394 long arg4 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 PyObject * obj2 = 0 ;
7398 PyObject * obj3 = 0 ;
7399 char *kwnames[] = {
7400 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7401 };
7402
7403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7405 if (SWIG_arg_fail(1)) SWIG_fail;
7406 {
7407 arg2 = static_cast<int >(SWIG_As_int(obj1));
7408 if (SWIG_arg_fail(2)) SWIG_fail;
7409 }
7410 {
7411 arg3 = static_cast<int >(SWIG_As_int(obj2));
7412 if (SWIG_arg_fail(3)) SWIG_fail;
7413 }
7414 {
7415 arg4 = static_cast<long >(SWIG_As_long(obj3));
7416 if (SWIG_arg_fail(4)) SWIG_fail;
7417 }
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7421
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 Py_INCREF(Py_None); resultobj = Py_None;
7426 return resultobj;
7427 fail:
7428 return NULL;
7429 }
7430
7431
7432 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj = NULL;
7434 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7435 int arg2 ;
7436 int arg3 ;
7437 double arg4 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 PyObject * obj2 = 0 ;
7441 PyObject * obj3 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 arg2 = static_cast<int >(SWIG_As_int(obj1));
7451 if (SWIG_arg_fail(2)) SWIG_fail;
7452 }
7453 {
7454 arg3 = static_cast<int >(SWIG_As_int(obj2));
7455 if (SWIG_arg_fail(3)) SWIG_fail;
7456 }
7457 {
7458 arg4 = static_cast<double >(SWIG_As_double(obj3));
7459 if (SWIG_arg_fail(4)) SWIG_fail;
7460 }
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 Py_INCREF(Py_None); resultobj = Py_None;
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj = NULL;
7477 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7478 int arg2 ;
7479 int arg3 ;
7480 bool arg4 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 PyObject * obj2 = 0 ;
7484 PyObject * obj3 = 0 ;
7485 char *kwnames[] = {
7486 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7487 };
7488
7489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7491 if (SWIG_arg_fail(1)) SWIG_fail;
7492 {
7493 arg2 = static_cast<int >(SWIG_As_int(obj1));
7494 if (SWIG_arg_fail(2)) SWIG_fail;
7495 }
7496 {
7497 arg3 = static_cast<int >(SWIG_As_int(obj2));
7498 if (SWIG_arg_fail(3)) SWIG_fail;
7499 }
7500 {
7501 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
7502 if (SWIG_arg_fail(4)) SWIG_fail;
7503 }
7504 {
7505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7506 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7507
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 Py_INCREF(Py_None); resultobj = Py_None;
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj = NULL;
7520 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7521 PyObject * obj0 = 0 ;
7522 char *kwnames[] = {
7523 (char *) "self", NULL
7524 };
7525
7526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7528 if (SWIG_arg_fail(1)) SWIG_fail;
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->Clear();
7532
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 Py_INCREF(Py_None); resultobj = Py_None;
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = NULL;
7545 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7546 size_t arg2 = (size_t) 0 ;
7547 size_t arg3 = (size_t) 1 ;
7548 bool result;
7549 PyObject * obj0 = 0 ;
7550 PyObject * obj1 = 0 ;
7551 PyObject * obj2 = 0 ;
7552 char *kwnames[] = {
7553 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7554 };
7555
7556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7558 if (SWIG_arg_fail(1)) SWIG_fail;
7559 if (obj1) {
7560 {
7561 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7562 if (SWIG_arg_fail(2)) SWIG_fail;
7563 }
7564 }
7565 if (obj2) {
7566 {
7567 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7568 if (SWIG_arg_fail(3)) SWIG_fail;
7569 }
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (bool)(arg1)->InsertRows(arg2,arg3);
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 {
7579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7580 }
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = NULL;
7589 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7590 size_t arg2 = (size_t) 1 ;
7591 bool result;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "self",(char *) "numRows", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(1)) SWIG_fail;
7601 if (obj1) {
7602 {
7603 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7604 if (SWIG_arg_fail(2)) SWIG_fail;
7605 }
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)(arg1)->AppendRows(arg2);
7610
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 {
7615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7616 }
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = NULL;
7625 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7626 size_t arg2 = (size_t) 0 ;
7627 size_t arg3 = (size_t) 1 ;
7628 bool result;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 PyObject * obj2 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7638 if (SWIG_arg_fail(1)) SWIG_fail;
7639 if (obj1) {
7640 {
7641 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7642 if (SWIG_arg_fail(2)) SWIG_fail;
7643 }
7644 }
7645 if (obj2) {
7646 {
7647 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7648 if (SWIG_arg_fail(3)) SWIG_fail;
7649 }
7650 }
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7654
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 {
7659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7660 }
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = NULL;
7669 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7670 size_t arg2 = (size_t) 0 ;
7671 size_t arg3 = (size_t) 1 ;
7672 bool result;
7673 PyObject * obj0 = 0 ;
7674 PyObject * obj1 = 0 ;
7675 PyObject * obj2 = 0 ;
7676 char *kwnames[] = {
7677 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7678 };
7679
7680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7682 if (SWIG_arg_fail(1)) SWIG_fail;
7683 if (obj1) {
7684 {
7685 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7686 if (SWIG_arg_fail(2)) SWIG_fail;
7687 }
7688 }
7689 if (obj2) {
7690 {
7691 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7692 if (SWIG_arg_fail(3)) SWIG_fail;
7693 }
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (bool)(arg1)->InsertCols(arg2,arg3);
7698
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 {
7703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7704 }
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj = NULL;
7713 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7714 size_t arg2 = (size_t) 1 ;
7715 bool result;
7716 PyObject * obj0 = 0 ;
7717 PyObject * obj1 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self",(char *) "numCols", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7724 if (SWIG_arg_fail(1)) SWIG_fail;
7725 if (obj1) {
7726 {
7727 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7728 if (SWIG_arg_fail(2)) SWIG_fail;
7729 }
7730 }
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 result = (bool)(arg1)->AppendCols(arg2);
7734
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 {
7739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7740 }
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7748 PyObject *resultobj = NULL;
7749 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7750 size_t arg2 = (size_t) 0 ;
7751 size_t arg3 = (size_t) 1 ;
7752 bool result;
7753 PyObject * obj0 = 0 ;
7754 PyObject * obj1 = 0 ;
7755 PyObject * obj2 = 0 ;
7756 char *kwnames[] = {
7757 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7758 };
7759
7760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7762 if (SWIG_arg_fail(1)) SWIG_fail;
7763 if (obj1) {
7764 {
7765 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7766 if (SWIG_arg_fail(2)) SWIG_fail;
7767 }
7768 }
7769 if (obj2) {
7770 {
7771 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7772 if (SWIG_arg_fail(3)) SWIG_fail;
7773 }
7774 }
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7778
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 {
7783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7784 }
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj = NULL;
7793 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7794 int arg2 ;
7795 wxString result;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char *kwnames[] = {
7799 (char *) "self",(char *) "row", NULL
7800 };
7801
7802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7804 if (SWIG_arg_fail(1)) SWIG_fail;
7805 {
7806 arg2 = static_cast<int >(SWIG_As_int(obj1));
7807 if (SWIG_arg_fail(2)) SWIG_fail;
7808 }
7809 {
7810 PyThreadState* __tstate = wxPyBeginAllowThreads();
7811 result = (arg1)->GetRowLabelValue(arg2);
7812
7813 wxPyEndAllowThreads(__tstate);
7814 if (PyErr_Occurred()) SWIG_fail;
7815 }
7816 {
7817 #if wxUSE_UNICODE
7818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7819 #else
7820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7821 #endif
7822 }
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7830 PyObject *resultobj = NULL;
7831 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7832 int arg2 ;
7833 wxString result;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char *kwnames[] = {
7837 (char *) "self",(char *) "col", NULL
7838 };
7839
7840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(1)) SWIG_fail;
7843 {
7844 arg2 = static_cast<int >(SWIG_As_int(obj1));
7845 if (SWIG_arg_fail(2)) SWIG_fail;
7846 }
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (arg1)->GetColLabelValue(arg2);
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 {
7855 #if wxUSE_UNICODE
7856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7857 #else
7858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7859 #endif
7860 }
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7868 PyObject *resultobj = NULL;
7869 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7870 int arg2 ;
7871 wxString *arg3 = 0 ;
7872 bool temp3 = false ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 PyObject * obj2 = 0 ;
7876 char *kwnames[] = {
7877 (char *) "self",(char *) "row",(char *) "value", NULL
7878 };
7879
7880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7882 if (SWIG_arg_fail(1)) SWIG_fail;
7883 {
7884 arg2 = static_cast<int >(SWIG_As_int(obj1));
7885 if (SWIG_arg_fail(2)) SWIG_fail;
7886 }
7887 {
7888 arg3 = wxString_in_helper(obj2);
7889 if (arg3 == NULL) SWIG_fail;
7890 temp3 = true;
7891 }
7892 {
7893 PyThreadState* __tstate = wxPyBeginAllowThreads();
7894 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7895
7896 wxPyEndAllowThreads(__tstate);
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 Py_INCREF(Py_None); resultobj = Py_None;
7900 {
7901 if (temp3)
7902 delete arg3;
7903 }
7904 return resultobj;
7905 fail:
7906 {
7907 if (temp3)
7908 delete arg3;
7909 }
7910 return NULL;
7911 }
7912
7913
7914 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj = NULL;
7916 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7917 int arg2 ;
7918 wxString *arg3 = 0 ;
7919 bool temp3 = false ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 PyObject * obj2 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self",(char *) "col",(char *) "value", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 {
7931 arg2 = static_cast<int >(SWIG_As_int(obj1));
7932 if (SWIG_arg_fail(2)) SWIG_fail;
7933 }
7934 {
7935 arg3 = wxString_in_helper(obj2);
7936 if (arg3 == NULL) SWIG_fail;
7937 temp3 = true;
7938 }
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 Py_INCREF(Py_None); resultobj = Py_None;
7947 {
7948 if (temp3)
7949 delete arg3;
7950 }
7951 return resultobj;
7952 fail:
7953 {
7954 if (temp3)
7955 delete arg3;
7956 }
7957 return NULL;
7958 }
7959
7960
7961 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7962 PyObject *resultobj = NULL;
7963 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7964 bool result;
7965 PyObject * obj0 = 0 ;
7966 char *kwnames[] = {
7967 (char *) "self", NULL
7968 };
7969
7970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
7971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7972 if (SWIG_arg_fail(1)) SWIG_fail;
7973 {
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 result = (bool)(arg1)->CanHaveAttributes();
7976
7977 wxPyEndAllowThreads(__tstate);
7978 if (PyErr_Occurred()) SWIG_fail;
7979 }
7980 {
7981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7982 }
7983 return resultobj;
7984 fail:
7985 return NULL;
7986 }
7987
7988
7989 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7990 PyObject *resultobj = NULL;
7991 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7992 int arg2 ;
7993 int arg3 ;
7994 wxGridCellAttr::wxAttrKind arg4 ;
7995 wxGridCellAttr *result;
7996 PyObject * obj0 = 0 ;
7997 PyObject * obj1 = 0 ;
7998 PyObject * obj2 = 0 ;
7999 PyObject * obj3 = 0 ;
8000 char *kwnames[] = {
8001 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8002 };
8003
8004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8006 if (SWIG_arg_fail(1)) SWIG_fail;
8007 {
8008 arg2 = static_cast<int >(SWIG_As_int(obj1));
8009 if (SWIG_arg_fail(2)) SWIG_fail;
8010 }
8011 {
8012 arg3 = static_cast<int >(SWIG_As_int(obj2));
8013 if (SWIG_arg_fail(3)) SWIG_fail;
8014 }
8015 {
8016 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
8017 if (SWIG_arg_fail(4)) SWIG_fail;
8018 }
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 {
8027 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
8028 }
8029 return resultobj;
8030 fail:
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj = NULL;
8037 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8038 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8039 int arg3 ;
8040 int arg4 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 PyObject * obj2 = 0 ;
8044 PyObject * obj3 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(2)) SWIG_fail;
8054 {
8055 arg3 = static_cast<int >(SWIG_As_int(obj2));
8056 if (SWIG_arg_fail(3)) SWIG_fail;
8057 }
8058 {
8059 arg4 = static_cast<int >(SWIG_As_int(obj3));
8060 if (SWIG_arg_fail(4)) SWIG_fail;
8061 }
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 (arg1)->SetAttr(arg2,arg3,arg4);
8065
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 Py_INCREF(Py_None); resultobj = Py_None;
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj = NULL;
8078 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8079 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8080 int arg3 ;
8081 PyObject * obj0 = 0 ;
8082 PyObject * obj1 = 0 ;
8083 PyObject * obj2 = 0 ;
8084 char *kwnames[] = {
8085 (char *) "self",(char *) "attr",(char *) "row", NULL
8086 };
8087
8088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8090 if (SWIG_arg_fail(1)) SWIG_fail;
8091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(2)) SWIG_fail;
8093 {
8094 arg3 = static_cast<int >(SWIG_As_int(obj2));
8095 if (SWIG_arg_fail(3)) SWIG_fail;
8096 }
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 (arg1)->SetRowAttr(arg2,arg3);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 Py_INCREF(Py_None); resultobj = Py_None;
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj = NULL;
8113 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8114 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8115 int arg3 ;
8116 PyObject * obj0 = 0 ;
8117 PyObject * obj1 = 0 ;
8118 PyObject * obj2 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "self",(char *) "attr",(char *) "col", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8125 if (SWIG_arg_fail(1)) SWIG_fail;
8126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8127 if (SWIG_arg_fail(2)) SWIG_fail;
8128 {
8129 arg3 = static_cast<int >(SWIG_As_int(obj2));
8130 if (SWIG_arg_fail(3)) SWIG_fail;
8131 }
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 (arg1)->SetColAttr(arg2,arg3);
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 Py_INCREF(Py_None); resultobj = Py_None;
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
8147 PyObject *obj;
8148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8149 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
8150 Py_INCREF(obj);
8151 return Py_BuildValue((char *)"");
8152 }
8153 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj = NULL;
8155 wxPyGridTableBase *result;
8156 char *kwnames[] = {
8157 NULL
8158 };
8159
8160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj = NULL;
8177 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8178 PyObject *arg2 = (PyObject *) 0 ;
8179 PyObject *arg3 = (PyObject *) 0 ;
8180 PyObject * obj0 = 0 ;
8181 PyObject * obj1 = 0 ;
8182 PyObject * obj2 = 0 ;
8183 char *kwnames[] = {
8184 (char *) "self",(char *) "self",(char *) "_class", NULL
8185 };
8186
8187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8189 if (SWIG_arg_fail(1)) SWIG_fail;
8190 arg2 = obj1;
8191 arg3 = obj2;
8192 {
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 (arg1)->_setCallbackInfo(arg2,arg3);
8195
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 Py_INCREF(Py_None); resultobj = Py_None;
8200 return resultobj;
8201 fail:
8202 return NULL;
8203 }
8204
8205
8206 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8207 PyObject *resultobj = NULL;
8208 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8209 PyObject * obj0 = 0 ;
8210 char *kwnames[] = {
8211 (char *) "self", NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8216 if (SWIG_arg_fail(1)) SWIG_fail;
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 wxPyGridTableBase_Destroy(arg1);
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 Py_INCREF(Py_None); resultobj = Py_None;
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 static PyObject *_wrap_PyGridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8232 PyObject *resultobj = NULL;
8233 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8234 int arg2 ;
8235 int arg3 ;
8236 wxString result;
8237 PyObject * obj0 = 0 ;
8238 PyObject * obj1 = 0 ;
8239 PyObject * obj2 = 0 ;
8240 char *kwnames[] = {
8241 (char *) "self",(char *) "row",(char *) "col", NULL
8242 };
8243
8244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8246 if (SWIG_arg_fail(1)) SWIG_fail;
8247 {
8248 arg2 = static_cast<int >(SWIG_As_int(obj1));
8249 if (SWIG_arg_fail(2)) SWIG_fail;
8250 }
8251 {
8252 arg3 = static_cast<int >(SWIG_As_int(obj2));
8253 if (SWIG_arg_fail(3)) SWIG_fail;
8254 }
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (arg1)->GetTypeName(arg2,arg3);
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 {
8263 #if wxUSE_UNICODE
8264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8265 #else
8266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8267 #endif
8268 }
8269 return resultobj;
8270 fail:
8271 return NULL;
8272 }
8273
8274
8275 static PyObject *_wrap_PyGridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8276 PyObject *resultobj = NULL;
8277 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8278 int arg2 ;
8279 int arg3 ;
8280 wxString *arg4 = 0 ;
8281 bool result;
8282 bool temp4 = false ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 PyObject * obj2 = 0 ;
8286 PyObject * obj3 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 {
8295 arg2 = static_cast<int >(SWIG_As_int(obj1));
8296 if (SWIG_arg_fail(2)) SWIG_fail;
8297 }
8298 {
8299 arg3 = static_cast<int >(SWIG_As_int(obj2));
8300 if (SWIG_arg_fail(3)) SWIG_fail;
8301 }
8302 {
8303 arg4 = wxString_in_helper(obj3);
8304 if (arg4 == NULL) SWIG_fail;
8305 temp4 = true;
8306 }
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 {
8315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8316 }
8317 {
8318 if (temp4)
8319 delete arg4;
8320 }
8321 return resultobj;
8322 fail:
8323 {
8324 if (temp4)
8325 delete arg4;
8326 }
8327 return NULL;
8328 }
8329
8330
8331 static PyObject *_wrap_PyGridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8332 PyObject *resultobj = NULL;
8333 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8334 int arg2 ;
8335 int arg3 ;
8336 wxString *arg4 = 0 ;
8337 bool result;
8338 bool temp4 = false ;
8339 PyObject * obj0 = 0 ;
8340 PyObject * obj1 = 0 ;
8341 PyObject * obj2 = 0 ;
8342 PyObject * obj3 = 0 ;
8343 char *kwnames[] = {
8344 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8345 };
8346
8347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8349 if (SWIG_arg_fail(1)) SWIG_fail;
8350 {
8351 arg2 = static_cast<int >(SWIG_As_int(obj1));
8352 if (SWIG_arg_fail(2)) SWIG_fail;
8353 }
8354 {
8355 arg3 = static_cast<int >(SWIG_As_int(obj2));
8356 if (SWIG_arg_fail(3)) SWIG_fail;
8357 }
8358 {
8359 arg4 = wxString_in_helper(obj3);
8360 if (arg4 == NULL) SWIG_fail;
8361 temp4 = true;
8362 }
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8366
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 {
8371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8372 }
8373 {
8374 if (temp4)
8375 delete arg4;
8376 }
8377 return resultobj;
8378 fail:
8379 {
8380 if (temp4)
8381 delete arg4;
8382 }
8383 return NULL;
8384 }
8385
8386
8387 static PyObject *_wrap_PyGridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8388 PyObject *resultobj = NULL;
8389 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8390 PyObject * obj0 = 0 ;
8391 char *kwnames[] = {
8392 (char *) "self", NULL
8393 };
8394
8395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Clear",kwnames,&obj0)) goto fail;
8396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8397 if (SWIG_arg_fail(1)) SWIG_fail;
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 (arg1)->Clear();
8401
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 Py_INCREF(Py_None); resultobj = Py_None;
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_PyGridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj = NULL;
8414 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8415 size_t arg2 = (size_t) 0 ;
8416 size_t arg3 = (size_t) 1 ;
8417 bool result;
8418 PyObject * obj0 = 0 ;
8419 PyObject * obj1 = 0 ;
8420 PyObject * obj2 = 0 ;
8421 char *kwnames[] = {
8422 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8427 if (SWIG_arg_fail(1)) SWIG_fail;
8428 if (obj1) {
8429 {
8430 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8431 if (SWIG_arg_fail(2)) SWIG_fail;
8432 }
8433 }
8434 if (obj2) {
8435 {
8436 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8437 if (SWIG_arg_fail(3)) SWIG_fail;
8438 }
8439 }
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (bool)(arg1)->InsertRows(arg2,arg3);
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8449 }
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 static PyObject *_wrap_PyGridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = NULL;
8458 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8459 size_t arg2 = (size_t) 1 ;
8460 bool result;
8461 PyObject * obj0 = 0 ;
8462 PyObject * obj1 = 0 ;
8463 char *kwnames[] = {
8464 (char *) "self",(char *) "numRows", NULL
8465 };
8466
8467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 if (obj1) {
8471 {
8472 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8473 if (SWIG_arg_fail(2)) SWIG_fail;
8474 }
8475 }
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 result = (bool)(arg1)->AppendRows(arg2);
8479
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 {
8484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8485 }
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 static PyObject *_wrap_PyGridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8493 PyObject *resultobj = NULL;
8494 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8495 size_t arg2 = (size_t) 0 ;
8496 size_t arg3 = (size_t) 1 ;
8497 bool result;
8498 PyObject * obj0 = 0 ;
8499 PyObject * obj1 = 0 ;
8500 PyObject * obj2 = 0 ;
8501 char *kwnames[] = {
8502 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8503 };
8504
8505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8507 if (SWIG_arg_fail(1)) SWIG_fail;
8508 if (obj1) {
8509 {
8510 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8511 if (SWIG_arg_fail(2)) SWIG_fail;
8512 }
8513 }
8514 if (obj2) {
8515 {
8516 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8517 if (SWIG_arg_fail(3)) SWIG_fail;
8518 }
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8523
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8529 }
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 static PyObject *_wrap_PyGridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = NULL;
8538 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8539 size_t arg2 = (size_t) 0 ;
8540 size_t arg3 = (size_t) 1 ;
8541 bool result;
8542 PyObject * obj0 = 0 ;
8543 PyObject * obj1 = 0 ;
8544 PyObject * obj2 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 if (obj1) {
8553 {
8554 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8555 if (SWIG_arg_fail(2)) SWIG_fail;
8556 }
8557 }
8558 if (obj2) {
8559 {
8560 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8561 if (SWIG_arg_fail(3)) SWIG_fail;
8562 }
8563 }
8564 {
8565 PyThreadState* __tstate = wxPyBeginAllowThreads();
8566 result = (bool)(arg1)->InsertCols(arg2,arg3);
8567
8568 wxPyEndAllowThreads(__tstate);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 {
8572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8573 }
8574 return resultobj;
8575 fail:
8576 return NULL;
8577 }
8578
8579
8580 static PyObject *_wrap_PyGridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj = NULL;
8582 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8583 size_t arg2 = (size_t) 1 ;
8584 bool result;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char *kwnames[] = {
8588 (char *) "self",(char *) "numCols", NULL
8589 };
8590
8591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8593 if (SWIG_arg_fail(1)) SWIG_fail;
8594 if (obj1) {
8595 {
8596 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8597 if (SWIG_arg_fail(2)) SWIG_fail;
8598 }
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 result = (bool)(arg1)->AppendCols(arg2);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8609 }
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 static PyObject *_wrap_PyGridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8617 PyObject *resultobj = NULL;
8618 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8619 size_t arg2 = (size_t) 0 ;
8620 size_t arg3 = (size_t) 1 ;
8621 bool result;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 PyObject * obj2 = 0 ;
8625 char *kwnames[] = {
8626 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8627 };
8628
8629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8631 if (SWIG_arg_fail(1)) SWIG_fail;
8632 if (obj1) {
8633 {
8634 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8635 if (SWIG_arg_fail(2)) SWIG_fail;
8636 }
8637 }
8638 if (obj2) {
8639 {
8640 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8641 if (SWIG_arg_fail(3)) SWIG_fail;
8642 }
8643 }
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8647
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 {
8652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8653 }
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 static PyObject *_wrap_PyGridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = NULL;
8662 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8663 int arg2 ;
8664 wxString result;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 char *kwnames[] = {
8668 (char *) "self",(char *) "row", NULL
8669 };
8670
8671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8673 if (SWIG_arg_fail(1)) SWIG_fail;
8674 {
8675 arg2 = static_cast<int >(SWIG_As_int(obj1));
8676 if (SWIG_arg_fail(2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 result = (arg1)->GetRowLabelValue(arg2);
8681
8682 wxPyEndAllowThreads(__tstate);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 {
8686 #if wxUSE_UNICODE
8687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8688 #else
8689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8690 #endif
8691 }
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 static PyObject *_wrap_PyGridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8699 PyObject *resultobj = NULL;
8700 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8701 int arg2 ;
8702 wxString result;
8703 PyObject * obj0 = 0 ;
8704 PyObject * obj1 = 0 ;
8705 char *kwnames[] = {
8706 (char *) "self",(char *) "col", NULL
8707 };
8708
8709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8711 if (SWIG_arg_fail(1)) SWIG_fail;
8712 {
8713 arg2 = static_cast<int >(SWIG_As_int(obj1));
8714 if (SWIG_arg_fail(2)) SWIG_fail;
8715 }
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 result = (arg1)->GetColLabelValue(arg2);
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 {
8724 #if wxUSE_UNICODE
8725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8726 #else
8727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8728 #endif
8729 }
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_PyGridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj = NULL;
8738 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8739 int arg2 ;
8740 wxString *arg3 = 0 ;
8741 bool temp3 = false ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745 char *kwnames[] = {
8746 (char *) "self",(char *) "row",(char *) "value", NULL
8747 };
8748
8749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8751 if (SWIG_arg_fail(1)) SWIG_fail;
8752 {
8753 arg2 = static_cast<int >(SWIG_As_int(obj1));
8754 if (SWIG_arg_fail(2)) SWIG_fail;
8755 }
8756 {
8757 arg3 = wxString_in_helper(obj2);
8758 if (arg3 == NULL) SWIG_fail;
8759 temp3 = true;
8760 }
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 {
8770 if (temp3)
8771 delete arg3;
8772 }
8773 return resultobj;
8774 fail:
8775 {
8776 if (temp3)
8777 delete arg3;
8778 }
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_PyGridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj = NULL;
8785 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8786 int arg2 ;
8787 wxString *arg3 = 0 ;
8788 bool temp3 = false ;
8789 PyObject * obj0 = 0 ;
8790 PyObject * obj1 = 0 ;
8791 PyObject * obj2 = 0 ;
8792 char *kwnames[] = {
8793 (char *) "self",(char *) "col",(char *) "value", NULL
8794 };
8795
8796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8798 if (SWIG_arg_fail(1)) SWIG_fail;
8799 {
8800 arg2 = static_cast<int >(SWIG_As_int(obj1));
8801 if (SWIG_arg_fail(2)) SWIG_fail;
8802 }
8803 {
8804 arg3 = wxString_in_helper(obj2);
8805 if (arg3 == NULL) SWIG_fail;
8806 temp3 = true;
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 Py_INCREF(Py_None); resultobj = Py_None;
8816 {
8817 if (temp3)
8818 delete arg3;
8819 }
8820 return resultobj;
8821 fail:
8822 {
8823 if (temp3)
8824 delete arg3;
8825 }
8826 return NULL;
8827 }
8828
8829
8830 static PyObject *_wrap_PyGridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj = NULL;
8832 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8833 bool result;
8834 PyObject * obj0 = 0 ;
8835 char *kwnames[] = {
8836 (char *) "self", NULL
8837 };
8838
8839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
8840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8841 if (SWIG_arg_fail(1)) SWIG_fail;
8842 {
8843 PyThreadState* __tstate = wxPyBeginAllowThreads();
8844 result = (bool)(arg1)->CanHaveAttributes();
8845
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 {
8850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8851 }
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_PyGridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj = NULL;
8860 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8861 int arg2 ;
8862 int arg3 ;
8863 wxGridCellAttr::wxAttrKind arg4 ;
8864 wxGridCellAttr *result;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 PyObject * obj2 = 0 ;
8868 PyObject * obj3 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 {
8877 arg2 = static_cast<int >(SWIG_As_int(obj1));
8878 if (SWIG_arg_fail(2)) SWIG_fail;
8879 }
8880 {
8881 arg3 = static_cast<int >(SWIG_As_int(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 {
8885 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
8886 if (SWIG_arg_fail(4)) SWIG_fail;
8887 }
8888 {
8889 PyThreadState* __tstate = wxPyBeginAllowThreads();
8890 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
8891
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 {
8896 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
8897 }
8898 return resultobj;
8899 fail:
8900 return NULL;
8901 }
8902
8903
8904 static PyObject *_wrap_PyGridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj = NULL;
8906 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8907 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8908 int arg3 ;
8909 int arg4 ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 PyObject * obj2 = 0 ;
8913 PyObject * obj3 = 0 ;
8914 char *kwnames[] = {
8915 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8916 };
8917
8918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8920 if (SWIG_arg_fail(1)) SWIG_fail;
8921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(2)) SWIG_fail;
8923 {
8924 arg3 = static_cast<int >(SWIG_As_int(obj2));
8925 if (SWIG_arg_fail(3)) SWIG_fail;
8926 }
8927 {
8928 arg4 = static_cast<int >(SWIG_As_int(obj3));
8929 if (SWIG_arg_fail(4)) SWIG_fail;
8930 }
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 (arg1)->SetAttr(arg2,arg3,arg4);
8934
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 Py_INCREF(Py_None); resultobj = Py_None;
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 static PyObject *_wrap_PyGridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = NULL;
8947 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8948 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8949 int arg3 ;
8950 PyObject * obj0 = 0 ;
8951 PyObject * obj1 = 0 ;
8952 PyObject * obj2 = 0 ;
8953 char *kwnames[] = {
8954 (char *) "self",(char *) "attr",(char *) "row", NULL
8955 };
8956
8957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8959 if (SWIG_arg_fail(1)) SWIG_fail;
8960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8961 if (SWIG_arg_fail(2)) SWIG_fail;
8962 {
8963 arg3 = static_cast<int >(SWIG_As_int(obj2));
8964 if (SWIG_arg_fail(3)) SWIG_fail;
8965 }
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 (arg1)->SetRowAttr(arg2,arg3);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 Py_INCREF(Py_None); resultobj = Py_None;
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_PyGridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj = NULL;
8982 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8983 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8984 int arg3 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 PyObject * obj2 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "attr",(char *) "col", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 {
8998 arg3 = static_cast<int >(SWIG_As_int(obj2));
8999 if (SWIG_arg_fail(3)) SWIG_fail;
9000 }
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 (arg1)->SetColAttr(arg2,arg3);
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
9016 PyObject *obj;
9017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9018 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
9019 Py_INCREF(obj);
9020 return Py_BuildValue((char *)"");
9021 }
9022 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
9023 PyObject *resultobj = NULL;
9024 int arg1 = (int) 0 ;
9025 int arg2 = (int) 0 ;
9026 wxGridStringTable *result;
9027 PyObject * obj0 = 0 ;
9028 PyObject * obj1 = 0 ;
9029 char *kwnames[] = {
9030 (char *) "numRows",(char *) "numCols", NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
9034 if (obj0) {
9035 {
9036 arg1 = static_cast<int >(SWIG_As_int(obj0));
9037 if (SWIG_arg_fail(1)) SWIG_fail;
9038 }
9039 }
9040 if (obj1) {
9041 {
9042 arg2 = static_cast<int >(SWIG_As_int(obj1));
9043 if (SWIG_arg_fail(2)) SWIG_fail;
9044 }
9045 }
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
9061 PyObject *obj;
9062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9063 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
9064 Py_INCREF(obj);
9065 return Py_BuildValue((char *)"");
9066 }
9067 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj = NULL;
9069 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9070 int arg2 ;
9071 int arg3 = (int) -1 ;
9072 int arg4 = (int) -1 ;
9073 wxGridTableMessage *result;
9074 PyObject * obj0 = 0 ;
9075 PyObject * obj1 = 0 ;
9076 PyObject * obj2 = 0 ;
9077 PyObject * obj3 = 0 ;
9078 char *kwnames[] = {
9079 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9080 };
9081
9082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9084 if (SWIG_arg_fail(1)) SWIG_fail;
9085 {
9086 arg2 = static_cast<int >(SWIG_As_int(obj1));
9087 if (SWIG_arg_fail(2)) SWIG_fail;
9088 }
9089 if (obj2) {
9090 {
9091 arg3 = static_cast<int >(SWIG_As_int(obj2));
9092 if (SWIG_arg_fail(3)) SWIG_fail;
9093 }
9094 }
9095 if (obj3) {
9096 {
9097 arg4 = static_cast<int >(SWIG_As_int(obj3));
9098 if (SWIG_arg_fail(4)) SWIG_fail;
9099 }
9100 }
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj = NULL;
9117 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9118 PyObject * obj0 = 0 ;
9119 char *kwnames[] = {
9120 (char *) "self", NULL
9121 };
9122
9123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
9124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9125 if (SWIG_arg_fail(1)) SWIG_fail;
9126 {
9127 PyThreadState* __tstate = wxPyBeginAllowThreads();
9128 delete arg1;
9129
9130 wxPyEndAllowThreads(__tstate);
9131 if (PyErr_Occurred()) SWIG_fail;
9132 }
9133 Py_INCREF(Py_None); resultobj = Py_None;
9134 return resultobj;
9135 fail:
9136 return NULL;
9137 }
9138
9139
9140 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj = NULL;
9142 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9143 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 char *kwnames[] = {
9147 (char *) "self",(char *) "table", NULL
9148 };
9149
9150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
9151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9152 if (SWIG_arg_fail(1)) SWIG_fail;
9153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9154 if (SWIG_arg_fail(2)) SWIG_fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 (arg1)->SetTableObject(arg2);
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 Py_INCREF(Py_None); resultobj = Py_None;
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj = NULL;
9171 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9172 wxGridTableBase *result;
9173 PyObject * obj0 = 0 ;
9174 char *kwnames[] = {
9175 (char *) "self", NULL
9176 };
9177
9178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9180 if (SWIG_arg_fail(1)) SWIG_fail;
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 {
9189 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9190 }
9191 return resultobj;
9192 fail:
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj = NULL;
9199 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9200 int arg2 ;
9201 PyObject * obj0 = 0 ;
9202 PyObject * obj1 = 0 ;
9203 char *kwnames[] = {
9204 (char *) "self",(char *) "id", NULL
9205 };
9206
9207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9209 if (SWIG_arg_fail(1)) SWIG_fail;
9210 {
9211 arg2 = static_cast<int >(SWIG_As_int(obj1));
9212 if (SWIG_arg_fail(2)) SWIG_fail;
9213 }
9214 {
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 (arg1)->SetId(arg2);
9217
9218 wxPyEndAllowThreads(__tstate);
9219 if (PyErr_Occurred()) SWIG_fail;
9220 }
9221 Py_INCREF(Py_None); resultobj = Py_None;
9222 return resultobj;
9223 fail:
9224 return NULL;
9225 }
9226
9227
9228 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9229 PyObject *resultobj = NULL;
9230 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9231 int result;
9232 PyObject * obj0 = 0 ;
9233 char *kwnames[] = {
9234 (char *) "self", NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9239 if (SWIG_arg_fail(1)) SWIG_fail;
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (int)(arg1)->GetId();
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 {
9248 resultobj = SWIG_From_int(static_cast<int >(result));
9249 }
9250 return resultobj;
9251 fail:
9252 return NULL;
9253 }
9254
9255
9256 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9257 PyObject *resultobj = NULL;
9258 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9259 int arg2 ;
9260 PyObject * obj0 = 0 ;
9261 PyObject * obj1 = 0 ;
9262 char *kwnames[] = {
9263 (char *) "self",(char *) "comInt1", NULL
9264 };
9265
9266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9268 if (SWIG_arg_fail(1)) SWIG_fail;
9269 {
9270 arg2 = static_cast<int >(SWIG_As_int(obj1));
9271 if (SWIG_arg_fail(2)) SWIG_fail;
9272 }
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 (arg1)->SetCommandInt(arg2);
9276
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 Py_INCREF(Py_None); resultobj = Py_None;
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj = NULL;
9289 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9290 int result;
9291 PyObject * obj0 = 0 ;
9292 char *kwnames[] = {
9293 (char *) "self", NULL
9294 };
9295
9296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9298 if (SWIG_arg_fail(1)) SWIG_fail;
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 result = (int)(arg1)->GetCommandInt();
9302
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 {
9307 resultobj = SWIG_From_int(static_cast<int >(result));
9308 }
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = NULL;
9317 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9318 int arg2 ;
9319 PyObject * obj0 = 0 ;
9320 PyObject * obj1 = 0 ;
9321 char *kwnames[] = {
9322 (char *) "self",(char *) "comInt2", NULL
9323 };
9324
9325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9327 if (SWIG_arg_fail(1)) SWIG_fail;
9328 {
9329 arg2 = static_cast<int >(SWIG_As_int(obj1));
9330 if (SWIG_arg_fail(2)) SWIG_fail;
9331 }
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 (arg1)->SetCommandInt2(arg2);
9335
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 Py_INCREF(Py_None); resultobj = Py_None;
9340 return resultobj;
9341 fail:
9342 return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj = NULL;
9348 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9349 int result;
9350 PyObject * obj0 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "self", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 result = (int)(arg1)->GetCommandInt2();
9361
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 {
9366 resultobj = SWIG_From_int(static_cast<int >(result));
9367 }
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9375 PyObject *obj;
9376 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9377 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9378 Py_INCREF(obj);
9379 return Py_BuildValue((char *)"");
9380 }
9381 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj = NULL;
9383 int arg1 = (int) -1 ;
9384 int arg2 = (int) -1 ;
9385 wxGridCellCoords *result;
9386 PyObject * obj0 = 0 ;
9387 PyObject * obj1 = 0 ;
9388 char *kwnames[] = {
9389 (char *) "r",(char *) "c", NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9393 if (obj0) {
9394 {
9395 arg1 = static_cast<int >(SWIG_As_int(obj0));
9396 if (SWIG_arg_fail(1)) SWIG_fail;
9397 }
9398 }
9399 if (obj1) {
9400 {
9401 arg2 = static_cast<int >(SWIG_As_int(obj1));
9402 if (SWIG_arg_fail(2)) SWIG_fail;
9403 }
9404 }
9405 {
9406 PyThreadState* __tstate = wxPyBeginAllowThreads();
9407 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9408
9409 wxPyEndAllowThreads(__tstate);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj = NULL;
9421 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9422 PyObject * obj0 = 0 ;
9423 char *kwnames[] = {
9424 (char *) "self", NULL
9425 };
9426
9427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9429 if (SWIG_arg_fail(1)) SWIG_fail;
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 delete arg1;
9433
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 Py_INCREF(Py_None); resultobj = Py_None;
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = NULL;
9446 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9447 int result;
9448 PyObject * obj0 = 0 ;
9449 char *kwnames[] = {
9450 (char *) "self", NULL
9451 };
9452
9453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9455 if (SWIG_arg_fail(1)) SWIG_fail;
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9459
9460 wxPyEndAllowThreads(__tstate);
9461 if (PyErr_Occurred()) SWIG_fail;
9462 }
9463 {
9464 resultobj = SWIG_From_int(static_cast<int >(result));
9465 }
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj = NULL;
9474 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9475 int arg2 ;
9476 PyObject * obj0 = 0 ;
9477 PyObject * obj1 = 0 ;
9478 char *kwnames[] = {
9479 (char *) "self",(char *) "n", NULL
9480 };
9481
9482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9484 if (SWIG_arg_fail(1)) SWIG_fail;
9485 {
9486 arg2 = static_cast<int >(SWIG_As_int(obj1));
9487 if (SWIG_arg_fail(2)) SWIG_fail;
9488 }
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 (arg1)->SetRow(arg2);
9492
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 Py_INCREF(Py_None); resultobj = Py_None;
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = NULL;
9505 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9506 int result;
9507 PyObject * obj0 = 0 ;
9508 char *kwnames[] = {
9509 (char *) "self", NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9514 if (SWIG_arg_fail(1)) SWIG_fail;
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 {
9523 resultobj = SWIG_From_int(static_cast<int >(result));
9524 }
9525 return resultobj;
9526 fail:
9527 return NULL;
9528 }
9529
9530
9531 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9532 PyObject *resultobj = NULL;
9533 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9534 int arg2 ;
9535 PyObject * obj0 = 0 ;
9536 PyObject * obj1 = 0 ;
9537 char *kwnames[] = {
9538 (char *) "self",(char *) "n", NULL
9539 };
9540
9541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9543 if (SWIG_arg_fail(1)) SWIG_fail;
9544 {
9545 arg2 = static_cast<int >(SWIG_As_int(obj1));
9546 if (SWIG_arg_fail(2)) SWIG_fail;
9547 }
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 (arg1)->SetCol(arg2);
9551
9552 wxPyEndAllowThreads(__tstate);
9553 if (PyErr_Occurred()) SWIG_fail;
9554 }
9555 Py_INCREF(Py_None); resultobj = Py_None;
9556 return resultobj;
9557 fail:
9558 return NULL;
9559 }
9560
9561
9562 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9563 PyObject *resultobj = NULL;
9564 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9565 int arg2 ;
9566 int arg3 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 PyObject * obj2 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "self",(char *) "row",(char *) "col", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9576 if (SWIG_arg_fail(1)) SWIG_fail;
9577 {
9578 arg2 = static_cast<int >(SWIG_As_int(obj1));
9579 if (SWIG_arg_fail(2)) SWIG_fail;
9580 }
9581 {
9582 arg3 = static_cast<int >(SWIG_As_int(obj2));
9583 if (SWIG_arg_fail(3)) SWIG_fail;
9584 }
9585 {
9586 PyThreadState* __tstate = wxPyBeginAllowThreads();
9587 (arg1)->Set(arg2,arg3);
9588
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 Py_INCREF(Py_None); resultobj = Py_None;
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj = NULL;
9601 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9602 wxGridCellCoords *arg2 = 0 ;
9603 bool result;
9604 wxGridCellCoords temp2 ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 char *kwnames[] = {
9608 (char *) "self",(char *) "other", NULL
9609 };
9610
9611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) goto fail;
9612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9613 if (SWIG_arg_fail(1)) SWIG_fail;
9614 {
9615 arg2 = &temp2;
9616 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9617 }
9618 {
9619 PyThreadState* __tstate = wxPyBeginAllowThreads();
9620 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9621
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 {
9626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9627 }
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = NULL;
9636 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9637 wxGridCellCoords *arg2 = 0 ;
9638 bool result;
9639 wxGridCellCoords temp2 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char *kwnames[] = {
9643 (char *) "self",(char *) "other", NULL
9644 };
9645
9646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9648 if (SWIG_arg_fail(1)) SWIG_fail;
9649 {
9650 arg2 = &temp2;
9651 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9652 }
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 {
9661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9662 }
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9670 PyObject *resultobj = NULL;
9671 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9672 PyObject *result;
9673 PyObject * obj0 = 0 ;
9674 char *kwnames[] = {
9675 (char *) "self", NULL
9676 };
9677
9678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9680 if (SWIG_arg_fail(1)) SWIG_fail;
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (PyObject *)wxGridCellCoords_Get(arg1);
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = result;
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9696 PyObject *obj;
9697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9698 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9699 Py_INCREF(obj);
9700 return Py_BuildValue((char *)"");
9701 }
9702 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj = NULL;
9704 wxWindow *arg1 = (wxWindow *) 0 ;
9705 int arg2 = (int) -1 ;
9706 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9707 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9708 wxSize const &arg4_defvalue = wxDefaultSize ;
9709 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9710 long arg5 = (long) wxWANTS_CHARS ;
9711 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9712 wxString *arg6 = (wxString *) &arg6_defvalue ;
9713 wxGrid *result;
9714 wxPoint temp3 ;
9715 wxSize temp4 ;
9716 bool temp6 = false ;
9717 PyObject * obj0 = 0 ;
9718 PyObject * obj1 = 0 ;
9719 PyObject * obj2 = 0 ;
9720 PyObject * obj3 = 0 ;
9721 PyObject * obj4 = 0 ;
9722 PyObject * obj5 = 0 ;
9723 char *kwnames[] = {
9724 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9725 };
9726
9727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9729 if (SWIG_arg_fail(1)) SWIG_fail;
9730 if (obj1) {
9731 {
9732 arg2 = static_cast<int >(SWIG_As_int(obj1));
9733 if (SWIG_arg_fail(2)) SWIG_fail;
9734 }
9735 }
9736 if (obj2) {
9737 {
9738 arg3 = &temp3;
9739 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9740 }
9741 }
9742 if (obj3) {
9743 {
9744 arg4 = &temp4;
9745 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9746 }
9747 }
9748 if (obj4) {
9749 {
9750 arg5 = static_cast<long >(SWIG_As_long(obj4));
9751 if (SWIG_arg_fail(5)) SWIG_fail;
9752 }
9753 }
9754 if (obj5) {
9755 {
9756 arg6 = wxString_in_helper(obj5);
9757 if (arg6 == NULL) SWIG_fail;
9758 temp6 = true;
9759 }
9760 }
9761 {
9762 if (!wxPyCheckForApp()) SWIG_fail;
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9770 {
9771 if (temp6)
9772 delete arg6;
9773 }
9774 return resultobj;
9775 fail:
9776 {
9777 if (temp6)
9778 delete arg6;
9779 }
9780 return NULL;
9781 }
9782
9783
9784 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj = NULL;
9786 wxGrid *result;
9787 char *kwnames[] = {
9788 NULL
9789 };
9790
9791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9792 {
9793 if (!wxPyCheckForApp()) SWIG_fail;
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 result = (wxGrid *)new wxGrid();
9796
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9808 PyObject *resultobj = NULL;
9809 wxGrid *arg1 = (wxGrid *) 0 ;
9810 wxWindow *arg2 = (wxWindow *) 0 ;
9811 int arg3 = (int) -1 ;
9812 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9813 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9814 wxSize const &arg5_defvalue = wxDefaultSize ;
9815 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9816 long arg6 = (long) wxWANTS_CHARS ;
9817 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9818 wxString *arg7 = (wxString *) &arg7_defvalue ;
9819 bool result;
9820 wxPoint temp4 ;
9821 wxSize temp5 ;
9822 bool temp7 = false ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 PyObject * obj2 = 0 ;
9826 PyObject * obj3 = 0 ;
9827 PyObject * obj4 = 0 ;
9828 PyObject * obj5 = 0 ;
9829 PyObject * obj6 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9838 if (SWIG_arg_fail(2)) SWIG_fail;
9839 if (obj2) {
9840 {
9841 arg3 = static_cast<int >(SWIG_As_int(obj2));
9842 if (SWIG_arg_fail(3)) SWIG_fail;
9843 }
9844 }
9845 if (obj3) {
9846 {
9847 arg4 = &temp4;
9848 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9849 }
9850 }
9851 if (obj4) {
9852 {
9853 arg5 = &temp5;
9854 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9855 }
9856 }
9857 if (obj5) {
9858 {
9859 arg6 = static_cast<long >(SWIG_As_long(obj5));
9860 if (SWIG_arg_fail(6)) SWIG_fail;
9861 }
9862 }
9863 if (obj6) {
9864 {
9865 arg7 = wxString_in_helper(obj6);
9866 if (arg7 == NULL) SWIG_fail;
9867 temp7 = true;
9868 }
9869 }
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9879 }
9880 {
9881 if (temp7)
9882 delete arg7;
9883 }
9884 return resultobj;
9885 fail:
9886 {
9887 if (temp7)
9888 delete arg7;
9889 }
9890 return NULL;
9891 }
9892
9893
9894 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = NULL;
9896 wxGrid *arg1 = (wxGrid *) 0 ;
9897 int arg2 ;
9898 int arg3 ;
9899 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9900 bool result;
9901 PyObject * obj0 = 0 ;
9902 PyObject * obj1 = 0 ;
9903 PyObject * obj2 = 0 ;
9904 PyObject * obj3 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 arg2 = static_cast<int >(SWIG_As_int(obj1));
9914 if (SWIG_arg_fail(2)) SWIG_fail;
9915 }
9916 {
9917 arg3 = static_cast<int >(SWIG_As_int(obj2));
9918 if (SWIG_arg_fail(3)) SWIG_fail;
9919 }
9920 if (obj3) {
9921 {
9922 arg4 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj3));
9923 if (SWIG_arg_fail(4)) SWIG_fail;
9924 }
9925 }
9926 {
9927 PyThreadState* __tstate = wxPyBeginAllowThreads();
9928 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9929
9930 wxPyEndAllowThreads(__tstate);
9931 if (PyErr_Occurred()) SWIG_fail;
9932 }
9933 {
9934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9935 }
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj = NULL;
9944 wxGrid *arg1 = (wxGrid *) 0 ;
9945 WXGRIDSELECTIONMODES arg2 ;
9946 PyObject * obj0 = 0 ;
9947 PyObject * obj1 = 0 ;
9948 char *kwnames[] = {
9949 (char *) "self",(char *) "selmode", NULL
9950 };
9951
9952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
9953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9954 if (SWIG_arg_fail(1)) SWIG_fail;
9955 {
9956 arg2 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj1));
9957 if (SWIG_arg_fail(2)) SWIG_fail;
9958 }
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 (arg1)->SetSelectionMode(arg2);
9962
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 Py_INCREF(Py_None); resultobj = Py_None;
9967 return resultobj;
9968 fail:
9969 return NULL;
9970 }
9971
9972
9973 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj = NULL;
9975 wxGrid *arg1 = (wxGrid *) 0 ;
9976 WXGRIDSELECTIONMODES result;
9977 PyObject * obj0 = 0 ;
9978 char *kwnames[] = {
9979 (char *) "self", NULL
9980 };
9981
9982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
9983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9984 if (SWIG_arg_fail(1)) SWIG_fail;
9985 {
9986 PyThreadState* __tstate = wxPyBeginAllowThreads();
9987 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
9988
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 {
9993 resultobj = SWIG_From_int(static_cast<int >(result));
9994 }
9995 return resultobj;
9996 fail:
9997 return NULL;
9998 }
9999
10000
10001 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj = NULL;
10003 wxGrid *arg1 = (wxGrid *) 0 ;
10004 int result;
10005 PyObject * obj0 = 0 ;
10006 char *kwnames[] = {
10007 (char *) "self", NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
10011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10012 if (SWIG_arg_fail(1)) SWIG_fail;
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 result = (int)(arg1)->GetNumberRows();
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 {
10021 resultobj = SWIG_From_int(static_cast<int >(result));
10022 }
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = NULL;
10031 wxGrid *arg1 = (wxGrid *) 0 ;
10032 int result;
10033 PyObject * obj0 = 0 ;
10034 char *kwnames[] = {
10035 (char *) "self", NULL
10036 };
10037
10038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
10039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10040 if (SWIG_arg_fail(1)) SWIG_fail;
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (int)(arg1)->GetNumberCols();
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 resultobj = SWIG_From_int(static_cast<int >(result));
10050 }
10051 return resultobj;
10052 fail:
10053 return NULL;
10054 }
10055
10056
10057 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10058 PyObject *resultobj = NULL;
10059 wxGrid *arg1 = (wxGrid *) 0 ;
10060 wxGridTableMessage *arg2 = 0 ;
10061 bool result;
10062 PyObject * obj0 = 0 ;
10063 PyObject * obj1 = 0 ;
10064 char *kwnames[] = {
10065 (char *) "self","arg2", NULL
10066 };
10067
10068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
10069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10070 if (SWIG_arg_fail(1)) SWIG_fail;
10071 {
10072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(2)) SWIG_fail;
10074 if (arg2 == NULL) {
10075 SWIG_null_ref("wxGridTableMessage");
10076 }
10077 if (SWIG_arg_fail(2)) SWIG_fail;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 {
10087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10088 }
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = NULL;
10097 wxGrid *arg1 = (wxGrid *) 0 ;
10098 wxGridTableBase *result;
10099 PyObject * obj0 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "self", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
10105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10106 if (SWIG_arg_fail(1)) SWIG_fail;
10107 {
10108 PyThreadState* __tstate = wxPyBeginAllowThreads();
10109 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10110
10111 wxPyEndAllowThreads(__tstate);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 {
10115 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10116 }
10117 return resultobj;
10118 fail:
10119 return NULL;
10120 }
10121
10122
10123 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
10124 PyObject *resultobj = NULL;
10125 wxGrid *arg1 = (wxGrid *) 0 ;
10126 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10127 bool arg3 = (bool) false ;
10128 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10129 bool result;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 PyObject * obj2 = 0 ;
10133 PyObject * obj3 = 0 ;
10134 char *kwnames[] = {
10135 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10136 };
10137
10138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10140 if (SWIG_arg_fail(1)) SWIG_fail;
10141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
10142 if (SWIG_arg_fail(2)) SWIG_fail;
10143 if (obj2) {
10144 {
10145 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10146 if (SWIG_arg_fail(3)) SWIG_fail;
10147 }
10148 }
10149 if (obj3) {
10150 {
10151 arg4 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj3));
10152 if (SWIG_arg_fail(4)) SWIG_fail;
10153 }
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10158
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 {
10163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10164 }
10165 return resultobj;
10166 fail:
10167 return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj = NULL;
10173 wxGrid *arg1 = (wxGrid *) 0 ;
10174 PyObject * obj0 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 (arg1)->ClearGrid();
10185
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 Py_INCREF(Py_None); resultobj = Py_None;
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = NULL;
10198 wxGrid *arg1 = (wxGrid *) 0 ;
10199 int arg2 = (int) 0 ;
10200 int arg3 = (int) 1 ;
10201 bool arg4 = (bool) true ;
10202 bool result;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 PyObject * obj2 = 0 ;
10206 PyObject * obj3 = 0 ;
10207 char *kwnames[] = {
10208 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10209 };
10210
10211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10213 if (SWIG_arg_fail(1)) SWIG_fail;
10214 if (obj1) {
10215 {
10216 arg2 = static_cast<int >(SWIG_As_int(obj1));
10217 if (SWIG_arg_fail(2)) SWIG_fail;
10218 }
10219 }
10220 if (obj2) {
10221 {
10222 arg3 = static_cast<int >(SWIG_As_int(obj2));
10223 if (SWIG_arg_fail(3)) SWIG_fail;
10224 }
10225 }
10226 if (obj3) {
10227 {
10228 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10229 if (SWIG_arg_fail(4)) SWIG_fail;
10230 }
10231 }
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10235
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 {
10240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10241 }
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = NULL;
10250 wxGrid *arg1 = (wxGrid *) 0 ;
10251 int arg2 = (int) 1 ;
10252 bool arg3 = (bool) true ;
10253 bool result;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 PyObject * obj2 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10263 if (SWIG_arg_fail(1)) SWIG_fail;
10264 if (obj1) {
10265 {
10266 arg2 = static_cast<int >(SWIG_As_int(obj1));
10267 if (SWIG_arg_fail(2)) SWIG_fail;
10268 }
10269 }
10270 if (obj2) {
10271 {
10272 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10273 if (SWIG_arg_fail(3)) SWIG_fail;
10274 }
10275 }
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (bool)(arg1)->AppendRows(arg2,arg3);
10279
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10285 }
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj = NULL;
10294 wxGrid *arg1 = (wxGrid *) 0 ;
10295 int arg2 = (int) 0 ;
10296 int arg3 = (int) 1 ;
10297 bool arg4 = (bool) true ;
10298 bool result;
10299 PyObject * obj0 = 0 ;
10300 PyObject * obj1 = 0 ;
10301 PyObject * obj2 = 0 ;
10302 PyObject * obj3 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 if (obj1) {
10311 {
10312 arg2 = static_cast<int >(SWIG_As_int(obj1));
10313 if (SWIG_arg_fail(2)) SWIG_fail;
10314 }
10315 }
10316 if (obj2) {
10317 {
10318 arg3 = static_cast<int >(SWIG_As_int(obj2));
10319 if (SWIG_arg_fail(3)) SWIG_fail;
10320 }
10321 }
10322 if (obj3) {
10323 {
10324 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10325 if (SWIG_arg_fail(4)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10337 }
10338 return resultobj;
10339 fail:
10340 return NULL;
10341 }
10342
10343
10344 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = NULL;
10346 wxGrid *arg1 = (wxGrid *) 0 ;
10347 int arg2 = (int) 0 ;
10348 int arg3 = (int) 1 ;
10349 bool arg4 = (bool) true ;
10350 bool result;
10351 PyObject * obj0 = 0 ;
10352 PyObject * obj1 = 0 ;
10353 PyObject * obj2 = 0 ;
10354 PyObject * obj3 = 0 ;
10355 char *kwnames[] = {
10356 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10357 };
10358
10359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 if (obj1) {
10363 {
10364 arg2 = static_cast<int >(SWIG_As_int(obj1));
10365 if (SWIG_arg_fail(2)) SWIG_fail;
10366 }
10367 }
10368 if (obj2) {
10369 {
10370 arg3 = static_cast<int >(SWIG_As_int(obj2));
10371 if (SWIG_arg_fail(3)) SWIG_fail;
10372 }
10373 }
10374 if (obj3) {
10375 {
10376 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10377 if (SWIG_arg_fail(4)) SWIG_fail;
10378 }
10379 }
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 {
10388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10389 }
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj = NULL;
10398 wxGrid *arg1 = (wxGrid *) 0 ;
10399 int arg2 = (int) 1 ;
10400 bool arg3 = (bool) true ;
10401 bool result;
10402 PyObject * obj0 = 0 ;
10403 PyObject * obj1 = 0 ;
10404 PyObject * obj2 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10411 if (SWIG_arg_fail(1)) SWIG_fail;
10412 if (obj1) {
10413 {
10414 arg2 = static_cast<int >(SWIG_As_int(obj1));
10415 if (SWIG_arg_fail(2)) SWIG_fail;
10416 }
10417 }
10418 if (obj2) {
10419 {
10420 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10421 if (SWIG_arg_fail(3)) SWIG_fail;
10422 }
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (bool)(arg1)->AppendCols(arg2,arg3);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj = NULL;
10442 wxGrid *arg1 = (wxGrid *) 0 ;
10443 int arg2 = (int) 0 ;
10444 int arg3 = (int) 1 ;
10445 bool arg4 = (bool) true ;
10446 bool result;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 PyObject * obj2 = 0 ;
10450 PyObject * obj3 = 0 ;
10451 char *kwnames[] = {
10452 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10453 };
10454
10455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10457 if (SWIG_arg_fail(1)) SWIG_fail;
10458 if (obj1) {
10459 {
10460 arg2 = static_cast<int >(SWIG_As_int(obj1));
10461 if (SWIG_arg_fail(2)) SWIG_fail;
10462 }
10463 }
10464 if (obj2) {
10465 {
10466 arg3 = static_cast<int >(SWIG_As_int(obj2));
10467 if (SWIG_arg_fail(3)) SWIG_fail;
10468 }
10469 }
10470 if (obj3) {
10471 {
10472 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10473 if (SWIG_arg_fail(4)) SWIG_fail;
10474 }
10475 }
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10479
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj = NULL;
10494 wxGrid *arg1 = (wxGrid *) 0 ;
10495 wxDC *arg2 = 0 ;
10496 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10497 PyObject * obj0 = 0 ;
10498 PyObject * obj1 = 0 ;
10499 PyObject * obj2 = 0 ;
10500 char *kwnames[] = {
10501 (char *) "self",(char *) "dc",(char *) "attr", NULL
10502 };
10503
10504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10506 if (SWIG_arg_fail(1)) SWIG_fail;
10507 {
10508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10509 if (SWIG_arg_fail(2)) SWIG_fail;
10510 if (arg2 == NULL) {
10511 SWIG_null_ref("wxDC");
10512 }
10513 if (SWIG_arg_fail(2)) SWIG_fail;
10514 }
10515 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10516 if (SWIG_arg_fail(3)) SWIG_fail;
10517 {
10518 PyThreadState* __tstate = wxPyBeginAllowThreads();
10519 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10520
10521 wxPyEndAllowThreads(__tstate);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 Py_INCREF(Py_None); resultobj = Py_None;
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10532 PyObject *resultobj = NULL;
10533 wxGrid *arg1 = (wxGrid *) 0 ;
10534 wxDC *arg2 = 0 ;
10535 wxString *arg3 = 0 ;
10536 wxRect *arg4 = 0 ;
10537 int arg5 = (int) wxLEFT ;
10538 int arg6 = (int) wxTOP ;
10539 int arg7 = (int) wxHORIZONTAL ;
10540 bool temp3 = false ;
10541 wxRect temp4 ;
10542 PyObject * obj0 = 0 ;
10543 PyObject * obj1 = 0 ;
10544 PyObject * obj2 = 0 ;
10545 PyObject * obj3 = 0 ;
10546 PyObject * obj4 = 0 ;
10547 PyObject * obj5 = 0 ;
10548 PyObject * obj6 = 0 ;
10549 char *kwnames[] = {
10550 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10551 };
10552
10553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10555 if (SWIG_arg_fail(1)) SWIG_fail;
10556 {
10557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10558 if (SWIG_arg_fail(2)) SWIG_fail;
10559 if (arg2 == NULL) {
10560 SWIG_null_ref("wxDC");
10561 }
10562 if (SWIG_arg_fail(2)) SWIG_fail;
10563 }
10564 {
10565 arg3 = wxString_in_helper(obj2);
10566 if (arg3 == NULL) SWIG_fail;
10567 temp3 = true;
10568 }
10569 {
10570 arg4 = &temp4;
10571 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10572 }
10573 if (obj4) {
10574 {
10575 arg5 = static_cast<int >(SWIG_As_int(obj4));
10576 if (SWIG_arg_fail(5)) SWIG_fail;
10577 }
10578 }
10579 if (obj5) {
10580 {
10581 arg6 = static_cast<int >(SWIG_As_int(obj5));
10582 if (SWIG_arg_fail(6)) SWIG_fail;
10583 }
10584 }
10585 if (obj6) {
10586 {
10587 arg7 = static_cast<int >(SWIG_As_int(obj6));
10588 if (SWIG_arg_fail(7)) SWIG_fail;
10589 }
10590 }
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10594
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 Py_INCREF(Py_None); resultobj = Py_None;
10599 {
10600 if (temp3)
10601 delete arg3;
10602 }
10603 return resultobj;
10604 fail:
10605 {
10606 if (temp3)
10607 delete arg3;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj = NULL;
10615 wxGrid *arg1 = (wxGrid *) 0 ;
10616 wxDC *arg2 = 0 ;
10617 wxArrayString *arg3 = 0 ;
10618 long *arg4 = (long *) 0 ;
10619 long *arg5 = (long *) 0 ;
10620 bool temp3 = false ;
10621 long temp4 ;
10622 int res4 = 0 ;
10623 long temp5 ;
10624 int res5 = 0 ;
10625 PyObject * obj0 = 0 ;
10626 PyObject * obj1 = 0 ;
10627 PyObject * obj2 = 0 ;
10628 char *kwnames[] = {
10629 (char *) "self",(char *) "dc",(char *) "lines", NULL
10630 };
10631
10632 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10633 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10636 if (SWIG_arg_fail(1)) SWIG_fail;
10637 {
10638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10639 if (SWIG_arg_fail(2)) SWIG_fail;
10640 if (arg2 == NULL) {
10641 SWIG_null_ref("wxDC");
10642 }
10643 if (SWIG_arg_fail(2)) SWIG_fail;
10644 }
10645 {
10646 if (! PySequence_Check(obj2)) {
10647 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10648 SWIG_fail;
10649 }
10650 arg3 = new wxArrayString;
10651 temp3 = true;
10652 int i, len=PySequence_Length(obj2);
10653 for (i=0; i<len; i++) {
10654 PyObject* item = PySequence_GetItem(obj2, i);
10655 wxString* s = wxString_in_helper(item);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 arg3->Add(*s);
10658 delete s;
10659 Py_DECREF(item);
10660 }
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10665
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 Py_INCREF(Py_None); resultobj = Py_None;
10670 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10671 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10672 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10673 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10674 {
10675 if (temp3) delete arg3;
10676 }
10677 return resultobj;
10678 fail:
10679 {
10680 if (temp3) delete arg3;
10681 }
10682 return NULL;
10683 }
10684
10685
10686 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj = NULL;
10688 wxGrid *arg1 = (wxGrid *) 0 ;
10689 PyObject * obj0 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 (arg1)->BeginBatch();
10700
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 Py_INCREF(Py_None); resultobj = Py_None;
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10712 PyObject *resultobj = NULL;
10713 wxGrid *arg1 = (wxGrid *) 0 ;
10714 PyObject * obj0 = 0 ;
10715 char *kwnames[] = {
10716 (char *) "self", NULL
10717 };
10718
10719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10721 if (SWIG_arg_fail(1)) SWIG_fail;
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 (arg1)->EndBatch();
10725
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 Py_INCREF(Py_None); resultobj = Py_None;
10730 return resultobj;
10731 fail:
10732 return NULL;
10733 }
10734
10735
10736 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj = NULL;
10738 wxGrid *arg1 = (wxGrid *) 0 ;
10739 int result;
10740 PyObject * obj0 = 0 ;
10741 char *kwnames[] = {
10742 (char *) "self", NULL
10743 };
10744
10745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10747 if (SWIG_arg_fail(1)) SWIG_fail;
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (int)(arg1)->GetBatchCount();
10751
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 resultobj = SWIG_From_int(static_cast<int >(result));
10757 }
10758 return resultobj;
10759 fail:
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj = NULL;
10766 wxGrid *arg1 = (wxGrid *) 0 ;
10767 PyObject * obj0 = 0 ;
10768 char *kwnames[] = {
10769 (char *) "self", NULL
10770 };
10771
10772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10774 if (SWIG_arg_fail(1)) SWIG_fail;
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 (arg1)->ForceRefresh();
10778
10779 wxPyEndAllowThreads(__tstate);
10780 if (PyErr_Occurred()) SWIG_fail;
10781 }
10782 Py_INCREF(Py_None); resultobj = Py_None;
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj = NULL;
10791 wxGrid *arg1 = (wxGrid *) 0 ;
10792 bool result;
10793 PyObject * obj0 = 0 ;
10794 char *kwnames[] = {
10795 (char *) "self", NULL
10796 };
10797
10798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (bool)(arg1)->IsEditable();
10804
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 {
10809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10810 }
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj = NULL;
10819 wxGrid *arg1 = (wxGrid *) 0 ;
10820 bool arg2 ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 char *kwnames[] = {
10824 (char *) "self",(char *) "edit", NULL
10825 };
10826
10827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10829 if (SWIG_arg_fail(1)) SWIG_fail;
10830 {
10831 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10832 if (SWIG_arg_fail(2)) SWIG_fail;
10833 }
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 (arg1)->EnableEditing(arg2);
10837
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 Py_INCREF(Py_None); resultobj = Py_None;
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10849 PyObject *resultobj = NULL;
10850 wxGrid *arg1 = (wxGrid *) 0 ;
10851 bool arg2 = (bool) true ;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 char *kwnames[] = {
10855 (char *) "self",(char *) "enable", NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10860 if (SWIG_arg_fail(1)) SWIG_fail;
10861 if (obj1) {
10862 {
10863 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10864 if (SWIG_arg_fail(2)) SWIG_fail;
10865 }
10866 }
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 (arg1)->EnableCellEditControl(arg2);
10870
10871 wxPyEndAllowThreads(__tstate);
10872 if (PyErr_Occurred()) SWIG_fail;
10873 }
10874 Py_INCREF(Py_None); resultobj = Py_None;
10875 return resultobj;
10876 fail:
10877 return NULL;
10878 }
10879
10880
10881 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10882 PyObject *resultobj = NULL;
10883 wxGrid *arg1 = (wxGrid *) 0 ;
10884 PyObject * obj0 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 (arg1)->DisableCellEditControl();
10895
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 Py_INCREF(Py_None); resultobj = Py_None;
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = NULL;
10908 wxGrid *arg1 = (wxGrid *) 0 ;
10909 bool result;
10910 PyObject * obj0 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "self", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10917 if (SWIG_arg_fail(1)) SWIG_fail;
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10921
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 {
10926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10927 }
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj = NULL;
10936 wxGrid *arg1 = (wxGrid *) 0 ;
10937 bool result;
10938 PyObject * obj0 = 0 ;
10939 char *kwnames[] = {
10940 (char *) "self", NULL
10941 };
10942
10943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
10944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10945 if (SWIG_arg_fail(1)) SWIG_fail;
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
10949
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 {
10954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = NULL;
10964 wxGrid *arg1 = (wxGrid *) 0 ;
10965 bool result;
10966 PyObject * obj0 = 0 ;
10967 char *kwnames[] = {
10968 (char *) "self", NULL
10969 };
10970
10971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
10972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10973 if (SWIG_arg_fail(1)) SWIG_fail;
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
10977
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10983 }
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj = NULL;
10992 wxGrid *arg1 = (wxGrid *) 0 ;
10993 bool result;
10994 PyObject * obj0 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj = NULL;
11020 wxGrid *arg1 = (wxGrid *) 0 ;
11021 PyObject * obj0 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 (arg1)->ShowCellEditControl();
11032
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 Py_INCREF(Py_None); resultobj = Py_None;
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = NULL;
11045 wxGrid *arg1 = (wxGrid *) 0 ;
11046 PyObject * obj0 = 0 ;
11047 char *kwnames[] = {
11048 (char *) "self", NULL
11049 };
11050
11051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
11052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11053 if (SWIG_arg_fail(1)) SWIG_fail;
11054 {
11055 PyThreadState* __tstate = wxPyBeginAllowThreads();
11056 (arg1)->HideCellEditControl();
11057
11058 wxPyEndAllowThreads(__tstate);
11059 if (PyErr_Occurred()) SWIG_fail;
11060 }
11061 Py_INCREF(Py_None); resultobj = Py_None;
11062 return resultobj;
11063 fail:
11064 return NULL;
11065 }
11066
11067
11068 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = NULL;
11070 wxGrid *arg1 = (wxGrid *) 0 ;
11071 PyObject * obj0 = 0 ;
11072 char *kwnames[] = {
11073 (char *) "self", NULL
11074 };
11075
11076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
11077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11078 if (SWIG_arg_fail(1)) SWIG_fail;
11079 {
11080 PyThreadState* __tstate = wxPyBeginAllowThreads();
11081 (arg1)->SaveEditControlValue();
11082
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 Py_INCREF(Py_None); resultobj = Py_None;
11087 return resultobj;
11088 fail:
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj = NULL;
11095 wxGrid *arg1 = (wxGrid *) 0 ;
11096 int arg2 ;
11097 int arg3 ;
11098 wxGridCellCoords result;
11099 PyObject * obj0 = 0 ;
11100 PyObject * obj1 = 0 ;
11101 PyObject * obj2 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self",(char *) "x",(char *) "y", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 arg2 = static_cast<int >(SWIG_As_int(obj1));
11111 if (SWIG_arg_fail(2)) SWIG_fail;
11112 }
11113 {
11114 arg3 = static_cast<int >(SWIG_As_int(obj2));
11115 if (SWIG_arg_fail(3)) SWIG_fail;
11116 }
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = wxGrid_XYToCell(arg1,arg2,arg3);
11120
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 {
11125 wxGridCellCoords * resultptr;
11126 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
11127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
11128 }
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj = NULL;
11137 wxGrid *arg1 = (wxGrid *) 0 ;
11138 int arg2 ;
11139 int result;
11140 PyObject * obj0 = 0 ;
11141 PyObject * obj1 = 0 ;
11142 char *kwnames[] = {
11143 (char *) "self",(char *) "y", NULL
11144 };
11145
11146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
11147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11148 if (SWIG_arg_fail(1)) SWIG_fail;
11149 {
11150 arg2 = static_cast<int >(SWIG_As_int(obj1));
11151 if (SWIG_arg_fail(2)) SWIG_fail;
11152 }
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 result = (int)(arg1)->YToRow(arg2);
11156
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 {
11161 resultobj = SWIG_From_int(static_cast<int >(result));
11162 }
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj = NULL;
11171 wxGrid *arg1 = (wxGrid *) 0 ;
11172 int arg2 ;
11173 int result;
11174 PyObject * obj0 = 0 ;
11175 PyObject * obj1 = 0 ;
11176 char *kwnames[] = {
11177 (char *) "self",(char *) "x", NULL
11178 };
11179
11180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11182 if (SWIG_arg_fail(1)) SWIG_fail;
11183 {
11184 arg2 = static_cast<int >(SWIG_As_int(obj1));
11185 if (SWIG_arg_fail(2)) SWIG_fail;
11186 }
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (int)(arg1)->XToCol(arg2);
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 resultobj = SWIG_From_int(static_cast<int >(result));
11196 }
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj = NULL;
11205 wxGrid *arg1 = (wxGrid *) 0 ;
11206 int arg2 ;
11207 int result;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self",(char *) "y", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 arg2 = static_cast<int >(SWIG_As_int(obj1));
11219 if (SWIG_arg_fail(2)) SWIG_fail;
11220 }
11221 {
11222 PyThreadState* __tstate = wxPyBeginAllowThreads();
11223 result = (int)(arg1)->YToEdgeOfRow(arg2);
11224
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 {
11229 resultobj = SWIG_From_int(static_cast<int >(result));
11230 }
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj = NULL;
11239 wxGrid *arg1 = (wxGrid *) 0 ;
11240 int arg2 ;
11241 int result;
11242 PyObject * obj0 = 0 ;
11243 PyObject * obj1 = 0 ;
11244 char *kwnames[] = {
11245 (char *) "self",(char *) "x", NULL
11246 };
11247
11248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11250 if (SWIG_arg_fail(1)) SWIG_fail;
11251 {
11252 arg2 = static_cast<int >(SWIG_As_int(obj1));
11253 if (SWIG_arg_fail(2)) SWIG_fail;
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 result = (int)(arg1)->XToEdgeOfCol(arg2);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 {
11263 resultobj = SWIG_From_int(static_cast<int >(result));
11264 }
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj = NULL;
11273 wxGrid *arg1 = (wxGrid *) 0 ;
11274 int arg2 ;
11275 int arg3 ;
11276 wxRect result;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self",(char *) "row",(char *) "col", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 {
11288 arg2 = static_cast<int >(SWIG_As_int(obj1));
11289 if (SWIG_arg_fail(2)) SWIG_fail;
11290 }
11291 {
11292 arg3 = static_cast<int >(SWIG_As_int(obj2));
11293 if (SWIG_arg_fail(3)) SWIG_fail;
11294 }
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 result = (arg1)->CellToRect(arg2,arg3);
11298
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 {
11303 wxRect * resultptr;
11304 resultptr = new wxRect(static_cast<wxRect & >(result));
11305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11306 }
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj = NULL;
11315 wxGrid *arg1 = (wxGrid *) 0 ;
11316 int result;
11317 PyObject * obj0 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 {
11326 PyThreadState* __tstate = wxPyBeginAllowThreads();
11327 result = (int)(arg1)->GetGridCursorRow();
11328
11329 wxPyEndAllowThreads(__tstate);
11330 if (PyErr_Occurred()) SWIG_fail;
11331 }
11332 {
11333 resultobj = SWIG_From_int(static_cast<int >(result));
11334 }
11335 return resultobj;
11336 fail:
11337 return NULL;
11338 }
11339
11340
11341 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj = NULL;
11343 wxGrid *arg1 = (wxGrid *) 0 ;
11344 int result;
11345 PyObject * obj0 = 0 ;
11346 char *kwnames[] = {
11347 (char *) "self", NULL
11348 };
11349
11350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11352 if (SWIG_arg_fail(1)) SWIG_fail;
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 result = (int)(arg1)->GetGridCursorCol();
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 {
11361 resultobj = SWIG_From_int(static_cast<int >(result));
11362 }
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj = NULL;
11371 wxGrid *arg1 = (wxGrid *) 0 ;
11372 int arg2 ;
11373 int arg3 ;
11374 bool arg4 = (bool) true ;
11375 bool result;
11376 PyObject * obj0 = 0 ;
11377 PyObject * obj1 = 0 ;
11378 PyObject * obj2 = 0 ;
11379 PyObject * obj3 = 0 ;
11380 char *kwnames[] = {
11381 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11382 };
11383
11384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11386 if (SWIG_arg_fail(1)) SWIG_fail;
11387 {
11388 arg2 = static_cast<int >(SWIG_As_int(obj1));
11389 if (SWIG_arg_fail(2)) SWIG_fail;
11390 }
11391 {
11392 arg3 = static_cast<int >(SWIG_As_int(obj2));
11393 if (SWIG_arg_fail(3)) SWIG_fail;
11394 }
11395 if (obj3) {
11396 {
11397 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11398 if (SWIG_arg_fail(4)) SWIG_fail;
11399 }
11400 }
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11404
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 {
11409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11410 }
11411 return resultobj;
11412 fail:
11413 return NULL;
11414 }
11415
11416
11417 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11418 PyObject *resultobj = NULL;
11419 wxGrid *arg1 = (wxGrid *) 0 ;
11420 int arg2 ;
11421 int arg3 ;
11422 PyObject * obj0 = 0 ;
11423 PyObject * obj1 = 0 ;
11424 PyObject * obj2 = 0 ;
11425 char *kwnames[] = {
11426 (char *) "self",(char *) "row",(char *) "col", NULL
11427 };
11428
11429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11431 if (SWIG_arg_fail(1)) SWIG_fail;
11432 {
11433 arg2 = static_cast<int >(SWIG_As_int(obj1));
11434 if (SWIG_arg_fail(2)) SWIG_fail;
11435 }
11436 {
11437 arg3 = static_cast<int >(SWIG_As_int(obj2));
11438 if (SWIG_arg_fail(3)) SWIG_fail;
11439 }
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 (arg1)->MakeCellVisible(arg2,arg3);
11443
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 Py_INCREF(Py_None); resultobj = Py_None;
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11455 PyObject *resultobj = NULL;
11456 wxGrid *arg1 = (wxGrid *) 0 ;
11457 int arg2 ;
11458 int arg3 ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 PyObject * obj2 = 0 ;
11462 char *kwnames[] = {
11463 (char *) "self",(char *) "row",(char *) "col", NULL
11464 };
11465
11466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11468 if (SWIG_arg_fail(1)) SWIG_fail;
11469 {
11470 arg2 = static_cast<int >(SWIG_As_int(obj1));
11471 if (SWIG_arg_fail(2)) SWIG_fail;
11472 }
11473 {
11474 arg3 = static_cast<int >(SWIG_As_int(obj2));
11475 if (SWIG_arg_fail(3)) SWIG_fail;
11476 }
11477 {
11478 PyThreadState* __tstate = wxPyBeginAllowThreads();
11479 (arg1)->SetGridCursor(arg2,arg3);
11480
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 Py_INCREF(Py_None); resultobj = Py_None;
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj = NULL;
11493 wxGrid *arg1 = (wxGrid *) 0 ;
11494 bool arg2 ;
11495 bool result;
11496 PyObject * obj0 = 0 ;
11497 PyObject * obj1 = 0 ;
11498 char *kwnames[] = {
11499 (char *) "self",(char *) "expandSelection", NULL
11500 };
11501
11502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11504 if (SWIG_arg_fail(1)) SWIG_fail;
11505 {
11506 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11507 if (SWIG_arg_fail(2)) SWIG_fail;
11508 }
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 result = (bool)(arg1)->MoveCursorUp(arg2);
11512
11513 wxPyEndAllowThreads(__tstate);
11514 if (PyErr_Occurred()) SWIG_fail;
11515 }
11516 {
11517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11518 }
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj = NULL;
11527 wxGrid *arg1 = (wxGrid *) 0 ;
11528 bool arg2 ;
11529 bool result;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "self",(char *) "expandSelection", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 {
11540 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11541 if (SWIG_arg_fail(2)) SWIG_fail;
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (bool)(arg1)->MoveCursorDown(arg2);
11546
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 {
11551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11552 }
11553 return resultobj;
11554 fail:
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = NULL;
11561 wxGrid *arg1 = (wxGrid *) 0 ;
11562 bool arg2 ;
11563 bool result;
11564 PyObject * obj0 = 0 ;
11565 PyObject * obj1 = 0 ;
11566 char *kwnames[] = {
11567 (char *) "self",(char *) "expandSelection", NULL
11568 };
11569
11570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11572 if (SWIG_arg_fail(1)) SWIG_fail;
11573 {
11574 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11575 if (SWIG_arg_fail(2)) SWIG_fail;
11576 }
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = (bool)(arg1)->MoveCursorLeft(arg2);
11580
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 {
11585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11586 }
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj = NULL;
11595 wxGrid *arg1 = (wxGrid *) 0 ;
11596 bool arg2 ;
11597 bool result;
11598 PyObject * obj0 = 0 ;
11599 PyObject * obj1 = 0 ;
11600 char *kwnames[] = {
11601 (char *) "self",(char *) "expandSelection", NULL
11602 };
11603
11604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 {
11608 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11609 if (SWIG_arg_fail(2)) SWIG_fail;
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (bool)(arg1)->MoveCursorRight(arg2);
11614
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 {
11619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11620 }
11621 return resultobj;
11622 fail:
11623 return NULL;
11624 }
11625
11626
11627 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj = NULL;
11629 wxGrid *arg1 = (wxGrid *) 0 ;
11630 bool result;
11631 PyObject * obj0 = 0 ;
11632 char *kwnames[] = {
11633 (char *) "self", NULL
11634 };
11635
11636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11638 if (SWIG_arg_fail(1)) SWIG_fail;
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (bool)(arg1)->MovePageDown();
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11656 PyObject *resultobj = NULL;
11657 wxGrid *arg1 = (wxGrid *) 0 ;
11658 bool result;
11659 PyObject * obj0 = 0 ;
11660 char *kwnames[] = {
11661 (char *) "self", NULL
11662 };
11663
11664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11666 if (SWIG_arg_fail(1)) SWIG_fail;
11667 {
11668 PyThreadState* __tstate = wxPyBeginAllowThreads();
11669 result = (bool)(arg1)->MovePageUp();
11670
11671 wxPyEndAllowThreads(__tstate);
11672 if (PyErr_Occurred()) SWIG_fail;
11673 }
11674 {
11675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11676 }
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 static PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11684 PyObject *resultobj = NULL;
11685 wxGrid *arg1 = (wxGrid *) 0 ;
11686 bool arg2 ;
11687 bool result;
11688 PyObject * obj0 = 0 ;
11689 PyObject * obj1 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "expandSelection", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11699 if (SWIG_arg_fail(2)) SWIG_fail;
11700 }
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
11704
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj = NULL;
11719 wxGrid *arg1 = (wxGrid *) 0 ;
11720 bool arg2 ;
11721 bool result;
11722 PyObject * obj0 = 0 ;
11723 PyObject * obj1 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self",(char *) "expandSelection", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11733 if (SWIG_arg_fail(2)) SWIG_fail;
11734 }
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
11738
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 static PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj = NULL;
11753 wxGrid *arg1 = (wxGrid *) 0 ;
11754 bool arg2 ;
11755 bool result;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 char *kwnames[] = {
11759 (char *) "self",(char *) "expandSelection", NULL
11760 };
11761
11762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) goto fail;
11763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11764 if (SWIG_arg_fail(1)) SWIG_fail;
11765 {
11766 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11767 if (SWIG_arg_fail(2)) SWIG_fail;
11768 }
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
11772
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 {
11777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11778 }
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11786 PyObject *resultobj = NULL;
11787 wxGrid *arg1 = (wxGrid *) 0 ;
11788 bool arg2 ;
11789 bool result;
11790 PyObject * obj0 = 0 ;
11791 PyObject * obj1 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "self",(char *) "expandSelection", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11798 if (SWIG_arg_fail(1)) SWIG_fail;
11799 {
11800 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11801 if (SWIG_arg_fail(2)) SWIG_fail;
11802 }
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11806
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 {
11811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11812 }
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11820 PyObject *resultobj = NULL;
11821 wxGrid *arg1 = (wxGrid *) 0 ;
11822 int result;
11823 PyObject * obj0 = 0 ;
11824 char *kwnames[] = {
11825 (char *) "self", NULL
11826 };
11827
11828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11830 if (SWIG_arg_fail(1)) SWIG_fail;
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 result = (int)(arg1)->GetDefaultRowLabelSize();
11834
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 {
11839 resultobj = SWIG_From_int(static_cast<int >(result));
11840 }
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11848 PyObject *resultobj = NULL;
11849 wxGrid *arg1 = (wxGrid *) 0 ;
11850 int result;
11851 PyObject * obj0 = 0 ;
11852 char *kwnames[] = {
11853 (char *) "self", NULL
11854 };
11855
11856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11858 if (SWIG_arg_fail(1)) SWIG_fail;
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (int)(arg1)->GetRowLabelSize();
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = SWIG_From_int(static_cast<int >(result));
11868 }
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj = NULL;
11877 wxGrid *arg1 = (wxGrid *) 0 ;
11878 int result;
11879 PyObject * obj0 = 0 ;
11880 char *kwnames[] = {
11881 (char *) "self", NULL
11882 };
11883
11884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11886 if (SWIG_arg_fail(1)) SWIG_fail;
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (int)(arg1)->GetDefaultColLabelSize();
11890
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = SWIG_From_int(static_cast<int >(result));
11896 }
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = NULL;
11905 wxGrid *arg1 = (wxGrid *) 0 ;
11906 int result;
11907 PyObject * obj0 = 0 ;
11908 char *kwnames[] = {
11909 (char *) "self", NULL
11910 };
11911
11912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11914 if (SWIG_arg_fail(1)) SWIG_fail;
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (int)(arg1)->GetColLabelSize();
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = SWIG_From_int(static_cast<int >(result));
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj = NULL;
11933 wxGrid *arg1 = (wxGrid *) 0 ;
11934 wxColour result;
11935 PyObject * obj0 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = (arg1)->GetLabelBackgroundColour();
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 wxColour * resultptr;
11952 resultptr = new wxColour(static_cast<wxColour & >(result));
11953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj = NULL;
11963 wxGrid *arg1 = (wxGrid *) 0 ;
11964 wxColour result;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (arg1)->GetLabelTextColour();
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 wxColour * resultptr;
11982 resultptr = new wxColour(static_cast<wxColour & >(result));
11983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj = NULL;
11993 wxGrid *arg1 = (wxGrid *) 0 ;
11994 wxFont result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (arg1)->GetLabelFont();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 wxFont * resultptr;
12012 resultptr = new wxFont(static_cast<wxFont & >(result));
12013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj = NULL;
12023 wxGrid *arg1 = (wxGrid *) 0 ;
12024 int *arg2 = (int *) 0 ;
12025 int *arg3 = (int *) 0 ;
12026 int temp2 ;
12027 int res2 = 0 ;
12028 int temp3 ;
12029 int res3 = 0 ;
12030 PyObject * obj0 = 0 ;
12031 char *kwnames[] = {
12032 (char *) "self", NULL
12033 };
12034
12035 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12036 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
12038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12039 if (SWIG_arg_fail(1)) SWIG_fail;
12040 {
12041 PyThreadState* __tstate = wxPyBeginAllowThreads();
12042 (arg1)->GetRowLabelAlignment(arg2,arg3);
12043
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 Py_INCREF(Py_None); resultobj = Py_None;
12048 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12049 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
12050 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12051 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj = NULL;
12060 wxGrid *arg1 = (wxGrid *) 0 ;
12061 int *arg2 = (int *) 0 ;
12062 int *arg3 = (int *) 0 ;
12063 int temp2 ;
12064 int res2 = 0 ;
12065 int temp3 ;
12066 int res3 = 0 ;
12067 PyObject * obj0 = 0 ;
12068 char *kwnames[] = {
12069 (char *) "self", NULL
12070 };
12071
12072 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12073 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
12075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12076 if (SWIG_arg_fail(1)) SWIG_fail;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 (arg1)->GetColLabelAlignment(arg2,arg3);
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 Py_INCREF(Py_None); resultobj = Py_None;
12085 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12086 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
12087 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12088 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = NULL;
12097 wxGrid *arg1 = (wxGrid *) 0 ;
12098 int result;
12099 PyObject * obj0 = 0 ;
12100 char *kwnames[] = {
12101 (char *) "self", NULL
12102 };
12103
12104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
12105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12106 if (SWIG_arg_fail(1)) SWIG_fail;
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (int)(arg1)->GetColLabelTextOrientation();
12110
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 {
12115 resultobj = SWIG_From_int(static_cast<int >(result));
12116 }
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = NULL;
12125 wxGrid *arg1 = (wxGrid *) 0 ;
12126 int arg2 ;
12127 wxString result;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self",(char *) "row", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 arg2 = static_cast<int >(SWIG_As_int(obj1));
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 }
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 result = (arg1)->GetRowLabelValue(arg2);
12144
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 {
12149 #if wxUSE_UNICODE
12150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12151 #else
12152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12153 #endif
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj = NULL;
12163 wxGrid *arg1 = (wxGrid *) 0 ;
12164 int arg2 ;
12165 wxString result;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self",(char *) "col", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 arg2 = static_cast<int >(SWIG_As_int(obj1));
12177 if (SWIG_arg_fail(2)) SWIG_fail;
12178 }
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (arg1)->GetColLabelValue(arg2);
12182
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 {
12187 #if wxUSE_UNICODE
12188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12189 #else
12190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12191 #endif
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj = NULL;
12201 wxGrid *arg1 = (wxGrid *) 0 ;
12202 wxColour result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (arg1)->GetGridLineColour();
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 wxColour * resultptr;
12220 resultptr = new wxColour(static_cast<wxColour & >(result));
12221 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12222 }
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = NULL;
12231 wxGrid *arg1 = (wxGrid *) 0 ;
12232 wxColour result;
12233 PyObject * obj0 = 0 ;
12234 char *kwnames[] = {
12235 (char *) "self", NULL
12236 };
12237
12238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12240 if (SWIG_arg_fail(1)) SWIG_fail;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (arg1)->GetCellHighlightColour();
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 {
12249 wxColour * resultptr;
12250 resultptr = new wxColour(static_cast<wxColour & >(result));
12251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj = NULL;
12261 wxGrid *arg1 = (wxGrid *) 0 ;
12262 int result;
12263 PyObject * obj0 = 0 ;
12264 char *kwnames[] = {
12265 (char *) "self", NULL
12266 };
12267
12268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12270 if (SWIG_arg_fail(1)) SWIG_fail;
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (int)(arg1)->GetCellHighlightPenWidth();
12274
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 {
12279 resultobj = SWIG_From_int(static_cast<int >(result));
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj = NULL;
12289 wxGrid *arg1 = (wxGrid *) 0 ;
12290 int result;
12291 PyObject * obj0 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "self", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(1)) SWIG_fail;
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = (int)(arg1)->GetCellHighlightROPenWidth();
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 resultobj = SWIG_From_int(static_cast<int >(result));
12308 }
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj = NULL;
12317 wxGrid *arg1 = (wxGrid *) 0 ;
12318 int arg2 ;
12319 PyObject * obj0 = 0 ;
12320 PyObject * obj1 = 0 ;
12321 char *kwnames[] = {
12322 (char *) "self",(char *) "width", NULL
12323 };
12324
12325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12327 if (SWIG_arg_fail(1)) SWIG_fail;
12328 {
12329 arg2 = static_cast<int >(SWIG_As_int(obj1));
12330 if (SWIG_arg_fail(2)) SWIG_fail;
12331 }
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 (arg1)->SetRowLabelSize(arg2);
12335
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 Py_INCREF(Py_None); resultobj = Py_None;
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj = NULL;
12348 wxGrid *arg1 = (wxGrid *) 0 ;
12349 int arg2 ;
12350 PyObject * obj0 = 0 ;
12351 PyObject * obj1 = 0 ;
12352 char *kwnames[] = {
12353 (char *) "self",(char *) "height", NULL
12354 };
12355
12356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12358 if (SWIG_arg_fail(1)) SWIG_fail;
12359 {
12360 arg2 = static_cast<int >(SWIG_As_int(obj1));
12361 if (SWIG_arg_fail(2)) SWIG_fail;
12362 }
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 (arg1)->SetColLabelSize(arg2);
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 Py_INCREF(Py_None); resultobj = Py_None;
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj = NULL;
12379 wxGrid *arg1 = (wxGrid *) 0 ;
12380 wxColour *arg2 = 0 ;
12381 wxColour temp2 ;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self","arg2", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 arg2 = &temp2;
12393 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12394 }
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12398
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 Py_INCREF(Py_None); resultobj = Py_None;
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12410 PyObject *resultobj = NULL;
12411 wxGrid *arg1 = (wxGrid *) 0 ;
12412 wxColour *arg2 = 0 ;
12413 wxColour temp2 ;
12414 PyObject * obj0 = 0 ;
12415 PyObject * obj1 = 0 ;
12416 char *kwnames[] = {
12417 (char *) "self","arg2", NULL
12418 };
12419
12420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",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 = &temp2;
12425 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12426 }
12427 {
12428 PyThreadState* __tstate = wxPyBeginAllowThreads();
12429 (arg1)->SetLabelTextColour((wxColour const &)*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_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = NULL;
12443 wxGrid *arg1 = (wxGrid *) 0 ;
12444 wxFont *arg2 = 0 ;
12445 PyObject * obj0 = 0 ;
12446 PyObject * obj1 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self","arg2", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12456 if (SWIG_arg_fail(2)) SWIG_fail;
12457 if (arg2 == NULL) {
12458 SWIG_null_ref("wxFont");
12459 }
12460 if (SWIG_arg_fail(2)) SWIG_fail;
12461 }
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 (arg1)->SetLabelFont((wxFont const &)*arg2);
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 Py_INCREF(Py_None); resultobj = Py_None;
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj = NULL;
12478 wxGrid *arg1 = (wxGrid *) 0 ;
12479 int arg2 ;
12480 int arg3 ;
12481 PyObject * obj0 = 0 ;
12482 PyObject * obj1 = 0 ;
12483 PyObject * obj2 = 0 ;
12484 char *kwnames[] = {
12485 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12486 };
12487
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 {
12492 arg2 = static_cast<int >(SWIG_As_int(obj1));
12493 if (SWIG_arg_fail(2)) SWIG_fail;
12494 }
12495 {
12496 arg3 = static_cast<int >(SWIG_As_int(obj2));
12497 if (SWIG_arg_fail(3)) SWIG_fail;
12498 }
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 (arg1)->SetRowLabelAlignment(arg2,arg3);
12502
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 Py_INCREF(Py_None); resultobj = Py_None;
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = NULL;
12515 wxGrid *arg1 = (wxGrid *) 0 ;
12516 int arg2 ;
12517 int arg3 ;
12518 PyObject * obj0 = 0 ;
12519 PyObject * obj1 = 0 ;
12520 PyObject * obj2 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 arg2 = static_cast<int >(SWIG_As_int(obj1));
12530 if (SWIG_arg_fail(2)) SWIG_fail;
12531 }
12532 {
12533 arg3 = static_cast<int >(SWIG_As_int(obj2));
12534 if (SWIG_arg_fail(3)) SWIG_fail;
12535 }
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 (arg1)->SetColLabelAlignment(arg2,arg3);
12539
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 Py_INCREF(Py_None); resultobj = Py_None;
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12551 PyObject *resultobj = NULL;
12552 wxGrid *arg1 = (wxGrid *) 0 ;
12553 int arg2 ;
12554 PyObject * obj0 = 0 ;
12555 PyObject * obj1 = 0 ;
12556 char *kwnames[] = {
12557 (char *) "self",(char *) "textOrientation", NULL
12558 };
12559
12560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12562 if (SWIG_arg_fail(1)) SWIG_fail;
12563 {
12564 arg2 = static_cast<int >(SWIG_As_int(obj1));
12565 if (SWIG_arg_fail(2)) SWIG_fail;
12566 }
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 (arg1)->SetColLabelTextOrientation(arg2);
12570
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 Py_INCREF(Py_None); resultobj = Py_None;
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = NULL;
12583 wxGrid *arg1 = (wxGrid *) 0 ;
12584 int arg2 ;
12585 wxString *arg3 = 0 ;
12586 bool temp3 = false ;
12587 PyObject * obj0 = 0 ;
12588 PyObject * obj1 = 0 ;
12589 PyObject * obj2 = 0 ;
12590 char *kwnames[] = {
12591 (char *) "self",(char *) "row","arg3", NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12596 if (SWIG_arg_fail(1)) SWIG_fail;
12597 {
12598 arg2 = static_cast<int >(SWIG_As_int(obj1));
12599 if (SWIG_arg_fail(2)) SWIG_fail;
12600 }
12601 {
12602 arg3 = wxString_in_helper(obj2);
12603 if (arg3 == NULL) SWIG_fail;
12604 temp3 = true;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 Py_INCREF(Py_None); resultobj = Py_None;
12614 {
12615 if (temp3)
12616 delete arg3;
12617 }
12618 return resultobj;
12619 fail:
12620 {
12621 if (temp3)
12622 delete arg3;
12623 }
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj = NULL;
12630 wxGrid *arg1 = (wxGrid *) 0 ;
12631 int arg2 ;
12632 wxString *arg3 = 0 ;
12633 bool temp3 = false ;
12634 PyObject * obj0 = 0 ;
12635 PyObject * obj1 = 0 ;
12636 PyObject * obj2 = 0 ;
12637 char *kwnames[] = {
12638 (char *) "self",(char *) "col","arg3", NULL
12639 };
12640
12641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12643 if (SWIG_arg_fail(1)) SWIG_fail;
12644 {
12645 arg2 = static_cast<int >(SWIG_As_int(obj1));
12646 if (SWIG_arg_fail(2)) SWIG_fail;
12647 }
12648 {
12649 arg3 = wxString_in_helper(obj2);
12650 if (arg3 == NULL) SWIG_fail;
12651 temp3 = true;
12652 }
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12656
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 Py_INCREF(Py_None); resultobj = Py_None;
12661 {
12662 if (temp3)
12663 delete arg3;
12664 }
12665 return resultobj;
12666 fail:
12667 {
12668 if (temp3)
12669 delete arg3;
12670 }
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj = NULL;
12677 wxGrid *arg1 = (wxGrid *) 0 ;
12678 wxColour *arg2 = 0 ;
12679 wxColour temp2 ;
12680 PyObject * obj0 = 0 ;
12681 PyObject * obj1 = 0 ;
12682 char *kwnames[] = {
12683 (char *) "self","arg2", NULL
12684 };
12685
12686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12688 if (SWIG_arg_fail(1)) SWIG_fail;
12689 {
12690 arg2 = &temp2;
12691 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12692 }
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12696
12697 wxPyEndAllowThreads(__tstate);
12698 if (PyErr_Occurred()) SWIG_fail;
12699 }
12700 Py_INCREF(Py_None); resultobj = Py_None;
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj = NULL;
12709 wxGrid *arg1 = (wxGrid *) 0 ;
12710 wxColour *arg2 = 0 ;
12711 wxColour temp2 ;
12712 PyObject * obj0 = 0 ;
12713 PyObject * obj1 = 0 ;
12714 char *kwnames[] = {
12715 (char *) "self","arg2", NULL
12716 };
12717
12718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) goto fail;
12719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12720 if (SWIG_arg_fail(1)) SWIG_fail;
12721 {
12722 arg2 = &temp2;
12723 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12724 }
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
12728
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 Py_INCREF(Py_None); resultobj = Py_None;
12733 return resultobj;
12734 fail:
12735 return NULL;
12736 }
12737
12738
12739 static PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12740 PyObject *resultobj = NULL;
12741 wxGrid *arg1 = (wxGrid *) 0 ;
12742 int arg2 ;
12743 PyObject * obj0 = 0 ;
12744 PyObject * obj1 = 0 ;
12745 char *kwnames[] = {
12746 (char *) "self",(char *) "width", NULL
12747 };
12748
12749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12751 if (SWIG_arg_fail(1)) SWIG_fail;
12752 {
12753 arg2 = static_cast<int >(SWIG_As_int(obj1));
12754 if (SWIG_arg_fail(2)) SWIG_fail;
12755 }
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 (arg1)->SetCellHighlightPenWidth(arg2);
12759
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 Py_INCREF(Py_None); resultobj = Py_None;
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12771 PyObject *resultobj = NULL;
12772 wxGrid *arg1 = (wxGrid *) 0 ;
12773 int arg2 ;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self",(char *) "width", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 arg2 = static_cast<int >(SWIG_As_int(obj1));
12785 if (SWIG_arg_fail(2)) SWIG_fail;
12786 }
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 (arg1)->SetCellHighlightROPenWidth(arg2);
12790
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 Py_INCREF(Py_None); resultobj = Py_None;
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12802 PyObject *resultobj = NULL;
12803 wxGrid *arg1 = (wxGrid *) 0 ;
12804 bool arg2 = (bool) true ;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 char *kwnames[] = {
12808 (char *) "self",(char *) "enable", NULL
12809 };
12810
12811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12813 if (SWIG_arg_fail(1)) SWIG_fail;
12814 if (obj1) {
12815 {
12816 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
12817 if (SWIG_arg_fail(2)) SWIG_fail;
12818 }
12819 }
12820 {
12821 PyThreadState* __tstate = wxPyBeginAllowThreads();
12822 (arg1)->EnableDragRowSize(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_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12835 PyObject *resultobj = NULL;
12836 wxGrid *arg1 = (wxGrid *) 0 ;
12837 PyObject * obj0 = 0 ;
12838 char *kwnames[] = {
12839 (char *) "self", NULL
12840 };
12841
12842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 (arg1)->DisableDragRowSize();
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 Py_INCREF(Py_None); resultobj = Py_None;
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj = NULL;
12861 wxGrid *arg1 = (wxGrid *) 0 ;
12862 bool result;
12863 PyObject * obj0 = 0 ;
12864 char *kwnames[] = {
12865 (char *) "self", NULL
12866 };
12867
12868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 {
12872 PyThreadState* __tstate = wxPyBeginAllowThreads();
12873 result = (bool)(arg1)->CanDragRowSize();
12874
12875 wxPyEndAllowThreads(__tstate);
12876 if (PyErr_Occurred()) SWIG_fail;
12877 }
12878 {
12879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12880 }
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12888 PyObject *resultobj = NULL;
12889 wxGrid *arg1 = (wxGrid *) 0 ;
12890 bool arg2 = (bool) true ;
12891 PyObject * obj0 = 0 ;
12892 PyObject * obj1 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self",(char *) "enable", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 if (obj1) {
12901 {
12902 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
12903 if (SWIG_arg_fail(2)) SWIG_fail;
12904 }
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 (arg1)->EnableDragColSize(arg2);
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 Py_INCREF(Py_None); resultobj = Py_None;
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj = NULL;
12922 wxGrid *arg1 = (wxGrid *) 0 ;
12923 PyObject * obj0 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 (arg1)->DisableDragColSize();
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 Py_INCREF(Py_None); resultobj = Py_None;
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj = NULL;
12947 wxGrid *arg1 = (wxGrid *) 0 ;
12948 bool result;
12949 PyObject * obj0 = 0 ;
12950 char *kwnames[] = {
12951 (char *) "self", NULL
12952 };
12953
12954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
12955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12956 if (SWIG_arg_fail(1)) SWIG_fail;
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (bool)(arg1)->CanDragColSize();
12960
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12966 }
12967 return resultobj;
12968 fail:
12969 return NULL;
12970 }
12971
12972
12973 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12974 PyObject *resultobj = NULL;
12975 wxGrid *arg1 = (wxGrid *) 0 ;
12976 bool arg2 = (bool) true ;
12977 PyObject * obj0 = 0 ;
12978 PyObject * obj1 = 0 ;
12979 char *kwnames[] = {
12980 (char *) "self",(char *) "enable", NULL
12981 };
12982
12983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
12984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12985 if (SWIG_arg_fail(1)) SWIG_fail;
12986 if (obj1) {
12987 {
12988 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
12989 if (SWIG_arg_fail(2)) SWIG_fail;
12990 }
12991 }
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 (arg1)->EnableDragGridSize(arg2);
12995
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 Py_INCREF(Py_None); resultobj = Py_None;
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = NULL;
13008 wxGrid *arg1 = (wxGrid *) 0 ;
13009 PyObject * obj0 = 0 ;
13010 char *kwnames[] = {
13011 (char *) "self", NULL
13012 };
13013
13014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
13015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13016 if (SWIG_arg_fail(1)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 (arg1)->DisableDragGridSize();
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 Py_INCREF(Py_None); resultobj = Py_None;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj = NULL;
13033 wxGrid *arg1 = (wxGrid *) 0 ;
13034 bool result;
13035 PyObject * obj0 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (bool)(arg1)->CanDragGridSize();
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13052 }
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj = NULL;
13061 wxGrid *arg1 = (wxGrid *) 0 ;
13062 bool arg2 = (bool) true ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 char *kwnames[] = {
13066 (char *) "self",(char *) "enable", NULL
13067 };
13068
13069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
13070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13071 if (SWIG_arg_fail(1)) SWIG_fail;
13072 if (obj1) {
13073 {
13074 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13075 if (SWIG_arg_fail(2)) SWIG_fail;
13076 }
13077 }
13078 {
13079 PyThreadState* __tstate = wxPyBeginAllowThreads();
13080 (arg1)->EnableDragCell(arg2);
13081
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 Py_INCREF(Py_None); resultobj = Py_None;
13086 return resultobj;
13087 fail:
13088 return NULL;
13089 }
13090
13091
13092 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13093 PyObject *resultobj = NULL;
13094 wxGrid *arg1 = (wxGrid *) 0 ;
13095 PyObject * obj0 = 0 ;
13096 char *kwnames[] = {
13097 (char *) "self", NULL
13098 };
13099
13100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
13101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13102 if (SWIG_arg_fail(1)) SWIG_fail;
13103 {
13104 PyThreadState* __tstate = wxPyBeginAllowThreads();
13105 (arg1)->DisableDragCell();
13106
13107 wxPyEndAllowThreads(__tstate);
13108 if (PyErr_Occurred()) SWIG_fail;
13109 }
13110 Py_INCREF(Py_None); resultobj = Py_None;
13111 return resultobj;
13112 fail:
13113 return NULL;
13114 }
13115
13116
13117 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = NULL;
13119 wxGrid *arg1 = (wxGrid *) 0 ;
13120 bool result;
13121 PyObject * obj0 = 0 ;
13122 char *kwnames[] = {
13123 (char *) "self", NULL
13124 };
13125
13126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
13127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13128 if (SWIG_arg_fail(1)) SWIG_fail;
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (bool)(arg1)->CanDragCell();
13132
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 {
13137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13138 }
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj = NULL;
13147 wxGrid *arg1 = (wxGrid *) 0 ;
13148 int arg2 ;
13149 int arg3 ;
13150 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 PyObject * obj2 = 0 ;
13154 PyObject * obj3 = 0 ;
13155 char *kwnames[] = {
13156 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
13157 };
13158
13159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13161 if (SWIG_arg_fail(1)) SWIG_fail;
13162 {
13163 arg2 = static_cast<int >(SWIG_As_int(obj1));
13164 if (SWIG_arg_fail(2)) SWIG_fail;
13165 }
13166 {
13167 arg3 = static_cast<int >(SWIG_As_int(obj2));
13168 if (SWIG_arg_fail(3)) SWIG_fail;
13169 }
13170 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(4)) SWIG_fail;
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 (arg1)->SetAttr(arg2,arg3,arg4);
13175
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 Py_INCREF(Py_None); resultobj = Py_None;
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj = NULL;
13188 wxGrid *arg1 = (wxGrid *) 0 ;
13189 int arg2 ;
13190 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 PyObject * obj2 = 0 ;
13194 char *kwnames[] = {
13195 (char *) "self",(char *) "row",(char *) "attr", NULL
13196 };
13197
13198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13200 if (SWIG_arg_fail(1)) SWIG_fail;
13201 {
13202 arg2 = static_cast<int >(SWIG_As_int(obj1));
13203 if (SWIG_arg_fail(2)) SWIG_fail;
13204 }
13205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13206 if (SWIG_arg_fail(3)) SWIG_fail;
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 (arg1)->SetRowAttr(arg2,arg3);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 Py_INCREF(Py_None); resultobj = Py_None;
13215 return resultobj;
13216 fail:
13217 return NULL;
13218 }
13219
13220
13221 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13222 PyObject *resultobj = NULL;
13223 wxGrid *arg1 = (wxGrid *) 0 ;
13224 int arg2 ;
13225 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 PyObject * obj2 = 0 ;
13229 char *kwnames[] = {
13230 (char *) "self",(char *) "col",(char *) "attr", NULL
13231 };
13232
13233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13235 if (SWIG_arg_fail(1)) SWIG_fail;
13236 {
13237 arg2 = static_cast<int >(SWIG_As_int(obj1));
13238 if (SWIG_arg_fail(2)) SWIG_fail;
13239 }
13240 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13241 if (SWIG_arg_fail(3)) SWIG_fail;
13242 {
13243 PyThreadState* __tstate = wxPyBeginAllowThreads();
13244 (arg1)->SetColAttr(arg2,arg3);
13245
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 Py_INCREF(Py_None); resultobj = Py_None;
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = NULL;
13258 wxGrid *arg1 = (wxGrid *) 0 ;
13259 int arg2 ;
13260 int arg3 ;
13261 wxGridCellAttr *result;
13262 PyObject * obj0 = 0 ;
13263 PyObject * obj1 = 0 ;
13264 PyObject * obj2 = 0 ;
13265 char *kwnames[] = {
13266 (char *) "self",(char *) "row",(char *) "col", NULL
13267 };
13268
13269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13271 if (SWIG_arg_fail(1)) SWIG_fail;
13272 {
13273 arg2 = static_cast<int >(SWIG_As_int(obj1));
13274 if (SWIG_arg_fail(2)) SWIG_fail;
13275 }
13276 {
13277 arg3 = static_cast<int >(SWIG_As_int(obj2));
13278 if (SWIG_arg_fail(3)) SWIG_fail;
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13283
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 {
13288 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
13289 }
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj = NULL;
13298 wxGrid *arg1 = (wxGrid *) 0 ;
13299 int arg2 ;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "col", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 {
13310 arg2 = static_cast<int >(SWIG_As_int(obj1));
13311 if (SWIG_arg_fail(2)) SWIG_fail;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 (arg1)->SetColFormatBool(arg2);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 Py_INCREF(Py_None); resultobj = Py_None;
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj = NULL;
13329 wxGrid *arg1 = (wxGrid *) 0 ;
13330 int arg2 ;
13331 PyObject * obj0 = 0 ;
13332 PyObject * obj1 = 0 ;
13333 char *kwnames[] = {
13334 (char *) "self",(char *) "col", NULL
13335 };
13336
13337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13339 if (SWIG_arg_fail(1)) SWIG_fail;
13340 {
13341 arg2 = static_cast<int >(SWIG_As_int(obj1));
13342 if (SWIG_arg_fail(2)) SWIG_fail;
13343 }
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 (arg1)->SetColFormatNumber(arg2);
13347
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 Py_INCREF(Py_None); resultobj = Py_None;
13352 return resultobj;
13353 fail:
13354 return NULL;
13355 }
13356
13357
13358 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13359 PyObject *resultobj = NULL;
13360 wxGrid *arg1 = (wxGrid *) 0 ;
13361 int arg2 ;
13362 int arg3 = (int) -1 ;
13363 int arg4 = (int) -1 ;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 PyObject * obj2 = 0 ;
13367 PyObject * obj3 = 0 ;
13368 char *kwnames[] = {
13369 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13370 };
13371
13372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13374 if (SWIG_arg_fail(1)) SWIG_fail;
13375 {
13376 arg2 = static_cast<int >(SWIG_As_int(obj1));
13377 if (SWIG_arg_fail(2)) SWIG_fail;
13378 }
13379 if (obj2) {
13380 {
13381 arg3 = static_cast<int >(SWIG_As_int(obj2));
13382 if (SWIG_arg_fail(3)) SWIG_fail;
13383 }
13384 }
13385 if (obj3) {
13386 {
13387 arg4 = static_cast<int >(SWIG_As_int(obj3));
13388 if (SWIG_arg_fail(4)) SWIG_fail;
13389 }
13390 }
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 Py_INCREF(Py_None); resultobj = Py_None;
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj = NULL;
13407 wxGrid *arg1 = (wxGrid *) 0 ;
13408 int arg2 ;
13409 wxString *arg3 = 0 ;
13410 bool temp3 = false ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 PyObject * obj2 = 0 ;
13414 char *kwnames[] = {
13415 (char *) "self",(char *) "col",(char *) "typeName", NULL
13416 };
13417
13418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13420 if (SWIG_arg_fail(1)) SWIG_fail;
13421 {
13422 arg2 = static_cast<int >(SWIG_As_int(obj1));
13423 if (SWIG_arg_fail(2)) SWIG_fail;
13424 }
13425 {
13426 arg3 = wxString_in_helper(obj2);
13427 if (arg3 == NULL) SWIG_fail;
13428 temp3 = true;
13429 }
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13433
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 Py_INCREF(Py_None); resultobj = Py_None;
13438 {
13439 if (temp3)
13440 delete arg3;
13441 }
13442 return resultobj;
13443 fail:
13444 {
13445 if (temp3)
13446 delete arg3;
13447 }
13448 return NULL;
13449 }
13450
13451
13452 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj = NULL;
13454 wxGrid *arg1 = (wxGrid *) 0 ;
13455 bool arg2 = (bool) true ;
13456 PyObject * obj0 = 0 ;
13457 PyObject * obj1 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "self",(char *) "enable", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13464 if (SWIG_arg_fail(1)) SWIG_fail;
13465 if (obj1) {
13466 {
13467 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13468 if (SWIG_arg_fail(2)) SWIG_fail;
13469 }
13470 }
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 (arg1)->EnableGridLines(arg2);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 Py_INCREF(Py_None); resultobj = Py_None;
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_Grid_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj = NULL;
13487 wxGrid *arg1 = (wxGrid *) 0 ;
13488 bool result;
13489 PyObject * obj0 = 0 ;
13490 char *kwnames[] = {
13491 (char *) "self", NULL
13492 };
13493
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13496 if (SWIG_arg_fail(1)) SWIG_fail;
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (bool)(arg1)->GridLinesEnabled();
13500
13501 wxPyEndAllowThreads(__tstate);
13502 if (PyErr_Occurred()) SWIG_fail;
13503 }
13504 {
13505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13506 }
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj = NULL;
13515 wxGrid *arg1 = (wxGrid *) 0 ;
13516 int result;
13517 PyObject * obj0 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 PyThreadState* __tstate = wxPyBeginAllowThreads();
13527 result = (int)(arg1)->GetDefaultRowSize();
13528
13529 wxPyEndAllowThreads(__tstate);
13530 if (PyErr_Occurred()) SWIG_fail;
13531 }
13532 {
13533 resultobj = SWIG_From_int(static_cast<int >(result));
13534 }
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = NULL;
13543 wxGrid *arg1 = (wxGrid *) 0 ;
13544 int arg2 ;
13545 int result;
13546 PyObject * obj0 = 0 ;
13547 PyObject * obj1 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "self",(char *) "row", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13554 if (SWIG_arg_fail(1)) SWIG_fail;
13555 {
13556 arg2 = static_cast<int >(SWIG_As_int(obj1));
13557 if (SWIG_arg_fail(2)) SWIG_fail;
13558 }
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (int)(arg1)->GetRowSize(arg2);
13562
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 {
13567 resultobj = SWIG_From_int(static_cast<int >(result));
13568 }
13569 return resultobj;
13570 fail:
13571 return NULL;
13572 }
13573
13574
13575 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13576 PyObject *resultobj = NULL;
13577 wxGrid *arg1 = (wxGrid *) 0 ;
13578 int result;
13579 PyObject * obj0 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 {
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (int)(arg1)->GetDefaultColSize();
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 {
13595 resultobj = SWIG_From_int(static_cast<int >(result));
13596 }
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = NULL;
13605 wxGrid *arg1 = (wxGrid *) 0 ;
13606 int arg2 ;
13607 int result;
13608 PyObject * obj0 = 0 ;
13609 PyObject * obj1 = 0 ;
13610 char *kwnames[] = {
13611 (char *) "self",(char *) "col", NULL
13612 };
13613
13614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13616 if (SWIG_arg_fail(1)) SWIG_fail;
13617 {
13618 arg2 = static_cast<int >(SWIG_As_int(obj1));
13619 if (SWIG_arg_fail(2)) SWIG_fail;
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 result = (int)(arg1)->GetColSize(arg2);
13624
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 {
13629 resultobj = SWIG_From_int(static_cast<int >(result));
13630 }
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj = NULL;
13639 wxGrid *arg1 = (wxGrid *) 0 ;
13640 wxColour result;
13641 PyObject * obj0 = 0 ;
13642 char *kwnames[] = {
13643 (char *) "self", NULL
13644 };
13645
13646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13648 if (SWIG_arg_fail(1)) SWIG_fail;
13649 {
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 result = (arg1)->GetDefaultCellBackgroundColour();
13652
13653 wxPyEndAllowThreads(__tstate);
13654 if (PyErr_Occurred()) SWIG_fail;
13655 }
13656 {
13657 wxColour * resultptr;
13658 resultptr = new wxColour(static_cast<wxColour & >(result));
13659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13660 }
13661 return resultobj;
13662 fail:
13663 return NULL;
13664 }
13665
13666
13667 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = NULL;
13669 wxGrid *arg1 = (wxGrid *) 0 ;
13670 int arg2 ;
13671 int arg3 ;
13672 wxColour result;
13673 PyObject * obj0 = 0 ;
13674 PyObject * obj1 = 0 ;
13675 PyObject * obj2 = 0 ;
13676 char *kwnames[] = {
13677 (char *) "self",(char *) "row",(char *) "col", NULL
13678 };
13679
13680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13682 if (SWIG_arg_fail(1)) SWIG_fail;
13683 {
13684 arg2 = static_cast<int >(SWIG_As_int(obj1));
13685 if (SWIG_arg_fail(2)) SWIG_fail;
13686 }
13687 {
13688 arg3 = static_cast<int >(SWIG_As_int(obj2));
13689 if (SWIG_arg_fail(3)) SWIG_fail;
13690 }
13691 {
13692 PyThreadState* __tstate = wxPyBeginAllowThreads();
13693 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13694
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 {
13699 wxColour * resultptr;
13700 resultptr = new wxColour(static_cast<wxColour & >(result));
13701 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13702 }
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13710 PyObject *resultobj = NULL;
13711 wxGrid *arg1 = (wxGrid *) 0 ;
13712 wxColour result;
13713 PyObject * obj0 = 0 ;
13714 char *kwnames[] = {
13715 (char *) "self", NULL
13716 };
13717
13718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13720 if (SWIG_arg_fail(1)) SWIG_fail;
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (arg1)->GetDefaultCellTextColour();
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 {
13729 wxColour * resultptr;
13730 resultptr = new wxColour(static_cast<wxColour & >(result));
13731 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13732 }
13733 return resultobj;
13734 fail:
13735 return NULL;
13736 }
13737
13738
13739 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13740 PyObject *resultobj = NULL;
13741 wxGrid *arg1 = (wxGrid *) 0 ;
13742 int arg2 ;
13743 int arg3 ;
13744 wxColour result;
13745 PyObject * obj0 = 0 ;
13746 PyObject * obj1 = 0 ;
13747 PyObject * obj2 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "row",(char *) "col", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = static_cast<int >(SWIG_As_int(obj1));
13757 if (SWIG_arg_fail(2)) SWIG_fail;
13758 }
13759 {
13760 arg3 = static_cast<int >(SWIG_As_int(obj2));
13761 if (SWIG_arg_fail(3)) SWIG_fail;
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = (arg1)->GetCellTextColour(arg2,arg3);
13766
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 {
13771 wxColour * resultptr;
13772 resultptr = new wxColour(static_cast<wxColour & >(result));
13773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13774 }
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj = NULL;
13783 wxGrid *arg1 = (wxGrid *) 0 ;
13784 wxFont result;
13785 PyObject * obj0 = 0 ;
13786 char *kwnames[] = {
13787 (char *) "self", NULL
13788 };
13789
13790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13792 if (SWIG_arg_fail(1)) SWIG_fail;
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 result = (arg1)->GetDefaultCellFont();
13796
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 {
13801 wxFont * resultptr;
13802 resultptr = new wxFont(static_cast<wxFont & >(result));
13803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13804 }
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj = NULL;
13813 wxGrid *arg1 = (wxGrid *) 0 ;
13814 int arg2 ;
13815 int arg3 ;
13816 wxFont result;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "self",(char *) "row",(char *) "col", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13826 if (SWIG_arg_fail(1)) SWIG_fail;
13827 {
13828 arg2 = static_cast<int >(SWIG_As_int(obj1));
13829 if (SWIG_arg_fail(2)) SWIG_fail;
13830 }
13831 {
13832 arg3 = static_cast<int >(SWIG_As_int(obj2));
13833 if (SWIG_arg_fail(3)) SWIG_fail;
13834 }
13835 {
13836 PyThreadState* __tstate = wxPyBeginAllowThreads();
13837 result = (arg1)->GetCellFont(arg2,arg3);
13838
13839 wxPyEndAllowThreads(__tstate);
13840 if (PyErr_Occurred()) SWIG_fail;
13841 }
13842 {
13843 wxFont * resultptr;
13844 resultptr = new wxFont(static_cast<wxFont & >(result));
13845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13846 }
13847 return resultobj;
13848 fail:
13849 return NULL;
13850 }
13851
13852
13853 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj = NULL;
13855 wxGrid *arg1 = (wxGrid *) 0 ;
13856 int *arg2 = (int *) 0 ;
13857 int *arg3 = (int *) 0 ;
13858 int temp2 ;
13859 int res2 = 0 ;
13860 int temp3 ;
13861 int res3 = 0 ;
13862 PyObject * obj0 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self", NULL
13865 };
13866
13867 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13868 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13871 if (SWIG_arg_fail(1)) SWIG_fail;
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13875
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 Py_INCREF(Py_None); resultobj = Py_None;
13880 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13881 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13882 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13883 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = NULL;
13892 wxGrid *arg1 = (wxGrid *) 0 ;
13893 int arg2 ;
13894 int arg3 ;
13895 int *arg4 = (int *) 0 ;
13896 int *arg5 = (int *) 0 ;
13897 int temp4 ;
13898 int res4 = 0 ;
13899 int temp5 ;
13900 int res5 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char *kwnames[] = {
13905 (char *) "self",(char *) "row",(char *) "col", NULL
13906 };
13907
13908 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13909 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
13911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13912 if (SWIG_arg_fail(1)) SWIG_fail;
13913 {
13914 arg2 = static_cast<int >(SWIG_As_int(obj1));
13915 if (SWIG_arg_fail(2)) SWIG_fail;
13916 }
13917 {
13918 arg3 = static_cast<int >(SWIG_As_int(obj2));
13919 if (SWIG_arg_fail(3)) SWIG_fail;
13920 }
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13924
13925 wxPyEndAllowThreads(__tstate);
13926 if (PyErr_Occurred()) SWIG_fail;
13927 }
13928 Py_INCREF(Py_None); resultobj = Py_None;
13929 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13930 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13931 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13932 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13933 return resultobj;
13934 fail:
13935 return NULL;
13936 }
13937
13938
13939 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13940 PyObject *resultobj = NULL;
13941 wxGrid *arg1 = (wxGrid *) 0 ;
13942 bool result;
13943 PyObject * obj0 = 0 ;
13944 char *kwnames[] = {
13945 (char *) "self", NULL
13946 };
13947
13948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",kwnames,&obj0)) goto fail;
13949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13950 if (SWIG_arg_fail(1)) SWIG_fail;
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 result = (bool)(arg1)->GetDefaultCellOverflow();
13954
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 {
13959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13960 }
13961 return resultobj;
13962 fail:
13963 return NULL;
13964 }
13965
13966
13967 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13968 PyObject *resultobj = NULL;
13969 wxGrid *arg1 = (wxGrid *) 0 ;
13970 int arg2 ;
13971 int arg3 ;
13972 bool result;
13973 PyObject * obj0 = 0 ;
13974 PyObject * obj1 = 0 ;
13975 PyObject * obj2 = 0 ;
13976 char *kwnames[] = {
13977 (char *) "self",(char *) "row",(char *) "col", NULL
13978 };
13979
13980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
13981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13982 if (SWIG_arg_fail(1)) SWIG_fail;
13983 {
13984 arg2 = static_cast<int >(SWIG_As_int(obj1));
13985 if (SWIG_arg_fail(2)) SWIG_fail;
13986 }
13987 {
13988 arg3 = static_cast<int >(SWIG_As_int(obj2));
13989 if (SWIG_arg_fail(3)) SWIG_fail;
13990 }
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
13994
13995 wxPyEndAllowThreads(__tstate);
13996 if (PyErr_Occurred()) SWIG_fail;
13997 }
13998 {
13999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14000 }
14001 return resultobj;
14002 fail:
14003 return NULL;
14004 }
14005
14006
14007 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14008 PyObject *resultobj = NULL;
14009 wxGrid *arg1 = (wxGrid *) 0 ;
14010 int arg2 ;
14011 int arg3 ;
14012 int *arg4 = (int *) 0 ;
14013 int *arg5 = (int *) 0 ;
14014 int temp4 ;
14015 int res4 = 0 ;
14016 int temp5 ;
14017 int res5 = 0 ;
14018 PyObject * obj0 = 0 ;
14019 PyObject * obj1 = 0 ;
14020 PyObject * obj2 = 0 ;
14021 char *kwnames[] = {
14022 (char *) "self",(char *) "row",(char *) "col", NULL
14023 };
14024
14025 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14026 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14029 if (SWIG_arg_fail(1)) SWIG_fail;
14030 {
14031 arg2 = static_cast<int >(SWIG_As_int(obj1));
14032 if (SWIG_arg_fail(2)) SWIG_fail;
14033 }
14034 {
14035 arg3 = static_cast<int >(SWIG_As_int(obj2));
14036 if (SWIG_arg_fail(3)) SWIG_fail;
14037 }
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
14041
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 Py_INCREF(Py_None); resultobj = Py_None;
14046 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14047 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14048 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14049 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj = NULL;
14058 wxGrid *arg1 = (wxGrid *) 0 ;
14059 int arg2 ;
14060 bool arg3 = (bool) false ;
14061 PyObject * obj0 = 0 ;
14062 PyObject * obj1 = 0 ;
14063 PyObject * obj2 = 0 ;
14064 char *kwnames[] = {
14065 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
14066 };
14067
14068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14070 if (SWIG_arg_fail(1)) SWIG_fail;
14071 {
14072 arg2 = static_cast<int >(SWIG_As_int(obj1));
14073 if (SWIG_arg_fail(2)) SWIG_fail;
14074 }
14075 if (obj2) {
14076 {
14077 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14078 if (SWIG_arg_fail(3)) SWIG_fail;
14079 }
14080 }
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 (arg1)->SetDefaultRowSize(arg2,arg3);
14084
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 Py_INCREF(Py_None); resultobj = Py_None;
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj = NULL;
14097 wxGrid *arg1 = (wxGrid *) 0 ;
14098 int arg2 ;
14099 int arg3 ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 char *kwnames[] = {
14104 (char *) "self",(char *) "row",(char *) "height", NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(1)) SWIG_fail;
14110 {
14111 arg2 = static_cast<int >(SWIG_As_int(obj1));
14112 if (SWIG_arg_fail(2)) SWIG_fail;
14113 }
14114 {
14115 arg3 = static_cast<int >(SWIG_As_int(obj2));
14116 if (SWIG_arg_fail(3)) SWIG_fail;
14117 }
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->SetRowSize(arg2,arg3);
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 Py_INCREF(Py_None); resultobj = Py_None;
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj = NULL;
14134 wxGrid *arg1 = (wxGrid *) 0 ;
14135 int arg2 ;
14136 bool arg3 = (bool) false ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 PyObject * obj2 = 0 ;
14140 char *kwnames[] = {
14141 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
14142 };
14143
14144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14146 if (SWIG_arg_fail(1)) SWIG_fail;
14147 {
14148 arg2 = static_cast<int >(SWIG_As_int(obj1));
14149 if (SWIG_arg_fail(2)) SWIG_fail;
14150 }
14151 if (obj2) {
14152 {
14153 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14154 if (SWIG_arg_fail(3)) SWIG_fail;
14155 }
14156 }
14157 {
14158 PyThreadState* __tstate = wxPyBeginAllowThreads();
14159 (arg1)->SetDefaultColSize(arg2,arg3);
14160
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 Py_INCREF(Py_None); resultobj = Py_None;
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj = NULL;
14173 wxGrid *arg1 = (wxGrid *) 0 ;
14174 int arg2 ;
14175 int arg3 ;
14176 PyObject * obj0 = 0 ;
14177 PyObject * obj1 = 0 ;
14178 PyObject * obj2 = 0 ;
14179 char *kwnames[] = {
14180 (char *) "self",(char *) "col",(char *) "width", NULL
14181 };
14182
14183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14185 if (SWIG_arg_fail(1)) SWIG_fail;
14186 {
14187 arg2 = static_cast<int >(SWIG_As_int(obj1));
14188 if (SWIG_arg_fail(2)) SWIG_fail;
14189 }
14190 {
14191 arg3 = static_cast<int >(SWIG_As_int(obj2));
14192 if (SWIG_arg_fail(3)) SWIG_fail;
14193 }
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 (arg1)->SetColSize(arg2,arg3);
14197
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 Py_INCREF(Py_None); resultobj = Py_None;
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj = NULL;
14210 wxGrid *arg1 = (wxGrid *) 0 ;
14211 int arg2 ;
14212 bool arg3 = (bool) true ;
14213 PyObject * obj0 = 0 ;
14214 PyObject * obj1 = 0 ;
14215 PyObject * obj2 = 0 ;
14216 char *kwnames[] = {
14217 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(1)) SWIG_fail;
14223 {
14224 arg2 = static_cast<int >(SWIG_As_int(obj1));
14225 if (SWIG_arg_fail(2)) SWIG_fail;
14226 }
14227 if (obj2) {
14228 {
14229 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14230 if (SWIG_arg_fail(3)) SWIG_fail;
14231 }
14232 }
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 (arg1)->AutoSizeColumn(arg2,arg3);
14236
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 Py_INCREF(Py_None); resultobj = Py_None;
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj = NULL;
14249 wxGrid *arg1 = (wxGrid *) 0 ;
14250 int arg2 ;
14251 bool arg3 = (bool) true ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 PyObject * obj2 = 0 ;
14255 char *kwnames[] = {
14256 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14257 };
14258
14259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 {
14263 arg2 = static_cast<int >(SWIG_As_int(obj1));
14264 if (SWIG_arg_fail(2)) SWIG_fail;
14265 }
14266 if (obj2) {
14267 {
14268 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14269 if (SWIG_arg_fail(3)) SWIG_fail;
14270 }
14271 }
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 (arg1)->AutoSizeRow(arg2,arg3);
14275
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 Py_INCREF(Py_None); resultobj = Py_None;
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj = NULL;
14288 wxGrid *arg1 = (wxGrid *) 0 ;
14289 bool arg2 = (bool) true ;
14290 PyObject * obj0 = 0 ;
14291 PyObject * obj1 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self",(char *) "setAsMin", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 if (obj1) {
14300 {
14301 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 }
14304 }
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 (arg1)->AutoSizeColumns(arg2);
14308
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 Py_INCREF(Py_None); resultobj = Py_None;
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = NULL;
14321 wxGrid *arg1 = (wxGrid *) 0 ;
14322 bool arg2 = (bool) true ;
14323 PyObject * obj0 = 0 ;
14324 PyObject * obj1 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self",(char *) "setAsMin", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 if (obj1) {
14333 {
14334 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
14335 if (SWIG_arg_fail(2)) SWIG_fail;
14336 }
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->AutoSizeRows(arg2);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj = NULL;
14354 wxGrid *arg1 = (wxGrid *) 0 ;
14355 PyObject * obj0 = 0 ;
14356 char *kwnames[] = {
14357 (char *) "self", NULL
14358 };
14359
14360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) 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 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 (arg1)->AutoSize();
14366
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 Py_INCREF(Py_None); resultobj = Py_None;
14371 return resultobj;
14372 fail:
14373 return NULL;
14374 }
14375
14376
14377 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14378 PyObject *resultobj = NULL;
14379 wxGrid *arg1 = (wxGrid *) 0 ;
14380 int arg2 ;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 char *kwnames[] = {
14384 (char *) "self",(char *) "row", NULL
14385 };
14386
14387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14389 if (SWIG_arg_fail(1)) SWIG_fail;
14390 {
14391 arg2 = static_cast<int >(SWIG_As_int(obj1));
14392 if (SWIG_arg_fail(2)) SWIG_fail;
14393 }
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 (arg1)->AutoSizeRowLabelSize(arg2);
14397
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 Py_INCREF(Py_None); resultobj = Py_None;
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj = NULL;
14410 wxGrid *arg1 = (wxGrid *) 0 ;
14411 int arg2 ;
14412 PyObject * obj0 = 0 ;
14413 PyObject * obj1 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self",(char *) "col", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 {
14422 arg2 = static_cast<int >(SWIG_As_int(obj1));
14423 if (SWIG_arg_fail(2)) SWIG_fail;
14424 }
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 (arg1)->AutoSizeColLabelSize(arg2);
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 Py_INCREF(Py_None); resultobj = Py_None;
14433 return resultobj;
14434 fail:
14435 return NULL;
14436 }
14437
14438
14439 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14440 PyObject *resultobj = NULL;
14441 wxGrid *arg1 = (wxGrid *) 0 ;
14442 int arg2 ;
14443 int arg3 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 PyObject * obj2 = 0 ;
14447 char *kwnames[] = {
14448 (char *) "self",(char *) "col",(char *) "width", NULL
14449 };
14450
14451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = static_cast<int >(SWIG_As_int(obj2));
14460 if (SWIG_arg_fail(3)) SWIG_fail;
14461 }
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 (arg1)->SetColMinimalWidth(arg2,arg3);
14465
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 Py_INCREF(Py_None); resultobj = Py_None;
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = NULL;
14478 wxGrid *arg1 = (wxGrid *) 0 ;
14479 int arg2 ;
14480 int arg3 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self",(char *) "row",(char *) "width", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 arg2 = static_cast<int >(SWIG_As_int(obj1));
14493 if (SWIG_arg_fail(2)) SWIG_fail;
14494 }
14495 {
14496 arg3 = static_cast<int >(SWIG_As_int(obj2));
14497 if (SWIG_arg_fail(3)) SWIG_fail;
14498 }
14499 {
14500 PyThreadState* __tstate = wxPyBeginAllowThreads();
14501 (arg1)->SetRowMinimalHeight(arg2,arg3);
14502
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 Py_INCREF(Py_None); resultobj = Py_None;
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj = NULL;
14515 wxGrid *arg1 = (wxGrid *) 0 ;
14516 int arg2 ;
14517 PyObject * obj0 = 0 ;
14518 PyObject * obj1 = 0 ;
14519 char *kwnames[] = {
14520 (char *) "self",(char *) "width", NULL
14521 };
14522
14523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14525 if (SWIG_arg_fail(1)) SWIG_fail;
14526 {
14527 arg2 = static_cast<int >(SWIG_As_int(obj1));
14528 if (SWIG_arg_fail(2)) SWIG_fail;
14529 }
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 (arg1)->SetColMinimalAcceptableWidth(arg2);
14533
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 Py_INCREF(Py_None); resultobj = Py_None;
14538 return resultobj;
14539 fail:
14540 return NULL;
14541 }
14542
14543
14544 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14545 PyObject *resultobj = NULL;
14546 wxGrid *arg1 = (wxGrid *) 0 ;
14547 int arg2 ;
14548 PyObject * obj0 = 0 ;
14549 PyObject * obj1 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self",(char *) "width", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 {
14558 arg2 = static_cast<int >(SWIG_As_int(obj1));
14559 if (SWIG_arg_fail(2)) SWIG_fail;
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14564
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 Py_INCREF(Py_None); resultobj = Py_None;
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14576 PyObject *resultobj = NULL;
14577 wxGrid *arg1 = (wxGrid *) 0 ;
14578 int result;
14579 PyObject * obj0 = 0 ;
14580 char *kwnames[] = {
14581 (char *) "self", NULL
14582 };
14583
14584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14586 if (SWIG_arg_fail(1)) SWIG_fail;
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14590
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 {
14595 resultobj = SWIG_From_int(static_cast<int >(result));
14596 }
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj = NULL;
14605 wxGrid *arg1 = (wxGrid *) 0 ;
14606 int result;
14607 PyObject * obj0 = 0 ;
14608 char *kwnames[] = {
14609 (char *) "self", NULL
14610 };
14611
14612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14614 if (SWIG_arg_fail(1)) SWIG_fail;
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14618
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 {
14623 resultobj = SWIG_From_int(static_cast<int >(result));
14624 }
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj = NULL;
14633 wxGrid *arg1 = (wxGrid *) 0 ;
14634 wxColour *arg2 = 0 ;
14635 wxColour temp2 ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 char *kwnames[] = {
14639 (char *) "self","arg2", NULL
14640 };
14641
14642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(1)) SWIG_fail;
14645 {
14646 arg2 = &temp2;
14647 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14648 }
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14652
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 Py_INCREF(Py_None); resultobj = Py_None;
14657 return resultobj;
14658 fail:
14659 return NULL;
14660 }
14661
14662
14663 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14664 PyObject *resultobj = NULL;
14665 wxGrid *arg1 = (wxGrid *) 0 ;
14666 int arg2 ;
14667 int arg3 ;
14668 wxColour *arg4 = 0 ;
14669 wxColour temp4 ;
14670 PyObject * obj0 = 0 ;
14671 PyObject * obj1 = 0 ;
14672 PyObject * obj2 = 0 ;
14673 PyObject * obj3 = 0 ;
14674 char *kwnames[] = {
14675 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14676 };
14677
14678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14680 if (SWIG_arg_fail(1)) SWIG_fail;
14681 {
14682 arg2 = static_cast<int >(SWIG_As_int(obj1));
14683 if (SWIG_arg_fail(2)) SWIG_fail;
14684 }
14685 {
14686 arg3 = static_cast<int >(SWIG_As_int(obj2));
14687 if (SWIG_arg_fail(3)) SWIG_fail;
14688 }
14689 {
14690 arg4 = &temp4;
14691 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14692 }
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14696
14697 wxPyEndAllowThreads(__tstate);
14698 if (PyErr_Occurred()) SWIG_fail;
14699 }
14700 Py_INCREF(Py_None); resultobj = Py_None;
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj = NULL;
14709 wxGrid *arg1 = (wxGrid *) 0 ;
14710 wxColour *arg2 = 0 ;
14711 wxColour temp2 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 char *kwnames[] = {
14715 (char *) "self","arg2", NULL
14716 };
14717
14718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14720 if (SWIG_arg_fail(1)) SWIG_fail;
14721 {
14722 arg2 = &temp2;
14723 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14724 }
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14728
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 Py_INCREF(Py_None); resultobj = Py_None;
14733 return resultobj;
14734 fail:
14735 return NULL;
14736 }
14737
14738
14739 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14740 PyObject *resultobj = NULL;
14741 wxGrid *arg1 = (wxGrid *) 0 ;
14742 int arg2 ;
14743 int arg3 ;
14744 wxColour *arg4 = 0 ;
14745 wxColour temp4 ;
14746 PyObject * obj0 = 0 ;
14747 PyObject * obj1 = 0 ;
14748 PyObject * obj2 = 0 ;
14749 PyObject * obj3 = 0 ;
14750 char *kwnames[] = {
14751 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14752 };
14753
14754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14756 if (SWIG_arg_fail(1)) SWIG_fail;
14757 {
14758 arg2 = static_cast<int >(SWIG_As_int(obj1));
14759 if (SWIG_arg_fail(2)) SWIG_fail;
14760 }
14761 {
14762 arg3 = static_cast<int >(SWIG_As_int(obj2));
14763 if (SWIG_arg_fail(3)) SWIG_fail;
14764 }
14765 {
14766 arg4 = &temp4;
14767 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14768 }
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14772
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 Py_INCREF(Py_None); resultobj = Py_None;
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14784 PyObject *resultobj = NULL;
14785 wxGrid *arg1 = (wxGrid *) 0 ;
14786 wxFont *arg2 = 0 ;
14787 PyObject * obj0 = 0 ;
14788 PyObject * obj1 = 0 ;
14789 char *kwnames[] = {
14790 (char *) "self","arg2", NULL
14791 };
14792
14793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14795 if (SWIG_arg_fail(1)) SWIG_fail;
14796 {
14797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14798 if (SWIG_arg_fail(2)) SWIG_fail;
14799 if (arg2 == NULL) {
14800 SWIG_null_ref("wxFont");
14801 }
14802 if (SWIG_arg_fail(2)) SWIG_fail;
14803 }
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14807
14808 wxPyEndAllowThreads(__tstate);
14809 if (PyErr_Occurred()) SWIG_fail;
14810 }
14811 Py_INCREF(Py_None); resultobj = Py_None;
14812 return resultobj;
14813 fail:
14814 return NULL;
14815 }
14816
14817
14818 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14819 PyObject *resultobj = NULL;
14820 wxGrid *arg1 = (wxGrid *) 0 ;
14821 int arg2 ;
14822 int arg3 ;
14823 wxFont *arg4 = 0 ;
14824 PyObject * obj0 = 0 ;
14825 PyObject * obj1 = 0 ;
14826 PyObject * obj2 = 0 ;
14827 PyObject * obj3 = 0 ;
14828 char *kwnames[] = {
14829 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14830 };
14831
14832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14834 if (SWIG_arg_fail(1)) SWIG_fail;
14835 {
14836 arg2 = static_cast<int >(SWIG_As_int(obj1));
14837 if (SWIG_arg_fail(2)) SWIG_fail;
14838 }
14839 {
14840 arg3 = static_cast<int >(SWIG_As_int(obj2));
14841 if (SWIG_arg_fail(3)) SWIG_fail;
14842 }
14843 {
14844 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14845 if (SWIG_arg_fail(4)) SWIG_fail;
14846 if (arg4 == NULL) {
14847 SWIG_null_ref("wxFont");
14848 }
14849 if (SWIG_arg_fail(4)) SWIG_fail;
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
14854
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 Py_INCREF(Py_None); resultobj = Py_None;
14859 return resultobj;
14860 fail:
14861 return NULL;
14862 }
14863
14864
14865 static PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj = NULL;
14867 wxGrid *arg1 = (wxGrid *) 0 ;
14868 int arg2 ;
14869 int arg3 ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 arg2 = static_cast<int >(SWIG_As_int(obj1));
14882 if (SWIG_arg_fail(2)) SWIG_fail;
14883 }
14884 {
14885 arg3 = static_cast<int >(SWIG_As_int(obj2));
14886 if (SWIG_arg_fail(3)) SWIG_fail;
14887 }
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14891
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 Py_INCREF(Py_None); resultobj = Py_None;
14896 return resultobj;
14897 fail:
14898 return NULL;
14899 }
14900
14901
14902 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14903 PyObject *resultobj = NULL;
14904 wxGrid *arg1 = (wxGrid *) 0 ;
14905 int arg2 ;
14906 int arg3 ;
14907 int arg4 ;
14908 int arg5 ;
14909 PyObject * obj0 = 0 ;
14910 PyObject * obj1 = 0 ;
14911 PyObject * obj2 = 0 ;
14912 PyObject * obj3 = 0 ;
14913 PyObject * obj4 = 0 ;
14914 char *kwnames[] = {
14915 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14916 };
14917
14918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14920 if (SWIG_arg_fail(1)) SWIG_fail;
14921 {
14922 arg2 = static_cast<int >(SWIG_As_int(obj1));
14923 if (SWIG_arg_fail(2)) SWIG_fail;
14924 }
14925 {
14926 arg3 = static_cast<int >(SWIG_As_int(obj2));
14927 if (SWIG_arg_fail(3)) SWIG_fail;
14928 }
14929 {
14930 arg4 = static_cast<int >(SWIG_As_int(obj3));
14931 if (SWIG_arg_fail(4)) SWIG_fail;
14932 }
14933 {
14934 arg5 = static_cast<int >(SWIG_As_int(obj4));
14935 if (SWIG_arg_fail(5)) SWIG_fail;
14936 }
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
14940
14941 wxPyEndAllowThreads(__tstate);
14942 if (PyErr_Occurred()) SWIG_fail;
14943 }
14944 Py_INCREF(Py_None); resultobj = Py_None;
14945 return resultobj;
14946 fail:
14947 return NULL;
14948 }
14949
14950
14951 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14952 PyObject *resultobj = NULL;
14953 wxGrid *arg1 = (wxGrid *) 0 ;
14954 bool arg2 ;
14955 PyObject * obj0 = 0 ;
14956 PyObject * obj1 = 0 ;
14957 char *kwnames[] = {
14958 (char *) "self",(char *) "allow", NULL
14959 };
14960
14961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
14962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14963 if (SWIG_arg_fail(1)) SWIG_fail;
14964 {
14965 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
14966 if (SWIG_arg_fail(2)) SWIG_fail;
14967 }
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 (arg1)->SetDefaultCellOverflow(arg2);
14971
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 Py_INCREF(Py_None); resultobj = Py_None;
14976 return resultobj;
14977 fail:
14978 return NULL;
14979 }
14980
14981
14982 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14983 PyObject *resultobj = NULL;
14984 wxGrid *arg1 = (wxGrid *) 0 ;
14985 int arg2 ;
14986 int arg3 ;
14987 bool arg4 ;
14988 PyObject * obj0 = 0 ;
14989 PyObject * obj1 = 0 ;
14990 PyObject * obj2 = 0 ;
14991 PyObject * obj3 = 0 ;
14992 char *kwnames[] = {
14993 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
14994 };
14995
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14998 if (SWIG_arg_fail(1)) SWIG_fail;
14999 {
15000 arg2 = static_cast<int >(SWIG_As_int(obj1));
15001 if (SWIG_arg_fail(2)) SWIG_fail;
15002 }
15003 {
15004 arg3 = static_cast<int >(SWIG_As_int(obj2));
15005 if (SWIG_arg_fail(3)) SWIG_fail;
15006 }
15007 {
15008 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15009 if (SWIG_arg_fail(4)) SWIG_fail;
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 (arg1)->SetCellOverflow(arg2,arg3,arg4);
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 Py_INCREF(Py_None); resultobj = Py_None;
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj = NULL;
15027 wxGrid *arg1 = (wxGrid *) 0 ;
15028 int arg2 ;
15029 int arg3 ;
15030 int arg4 ;
15031 int arg5 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 PyObject * obj2 = 0 ;
15035 PyObject * obj3 = 0 ;
15036 PyObject * obj4 = 0 ;
15037 char *kwnames[] = {
15038 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
15039 };
15040
15041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15043 if (SWIG_arg_fail(1)) SWIG_fail;
15044 {
15045 arg2 = static_cast<int >(SWIG_As_int(obj1));
15046 if (SWIG_arg_fail(2)) SWIG_fail;
15047 }
15048 {
15049 arg3 = static_cast<int >(SWIG_As_int(obj2));
15050 if (SWIG_arg_fail(3)) SWIG_fail;
15051 }
15052 {
15053 arg4 = static_cast<int >(SWIG_As_int(obj3));
15054 if (SWIG_arg_fail(4)) SWIG_fail;
15055 }
15056 {
15057 arg5 = static_cast<int >(SWIG_As_int(obj4));
15058 if (SWIG_arg_fail(5)) SWIG_fail;
15059 }
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 Py_INCREF(Py_None); resultobj = Py_None;
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15075 PyObject *resultobj = NULL;
15076 wxGrid *arg1 = (wxGrid *) 0 ;
15077 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
15078 PyObject * obj0 = 0 ;
15079 PyObject * obj1 = 0 ;
15080 char *kwnames[] = {
15081 (char *) "self",(char *) "renderer", NULL
15082 };
15083
15084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
15085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(1)) SWIG_fail;
15087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
15088 if (SWIG_arg_fail(2)) SWIG_fail;
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 (arg1)->SetDefaultRenderer(arg2);
15092
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 Py_INCREF(Py_None); resultobj = Py_None;
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15104 PyObject *resultobj = NULL;
15105 wxGrid *arg1 = (wxGrid *) 0 ;
15106 int arg2 ;
15107 int arg3 ;
15108 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
15109 PyObject * obj0 = 0 ;
15110 PyObject * obj1 = 0 ;
15111 PyObject * obj2 = 0 ;
15112 PyObject * obj3 = 0 ;
15113 char *kwnames[] = {
15114 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
15115 };
15116
15117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15119 if (SWIG_arg_fail(1)) SWIG_fail;
15120 {
15121 arg2 = static_cast<int >(SWIG_As_int(obj1));
15122 if (SWIG_arg_fail(2)) SWIG_fail;
15123 }
15124 {
15125 arg3 = static_cast<int >(SWIG_As_int(obj2));
15126 if (SWIG_arg_fail(3)) SWIG_fail;
15127 }
15128 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
15129 if (SWIG_arg_fail(4)) SWIG_fail;
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 (arg1)->SetCellRenderer(arg2,arg3,arg4);
15133
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 Py_INCREF(Py_None); resultobj = Py_None;
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj = NULL;
15146 wxGrid *arg1 = (wxGrid *) 0 ;
15147 wxGridCellRenderer *result;
15148 PyObject * obj0 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15159
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 {
15164 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
15165 }
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = NULL;
15174 wxGrid *arg1 = (wxGrid *) 0 ;
15175 int arg2 ;
15176 int arg3 ;
15177 wxGridCellRenderer *result;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 char *kwnames[] = {
15182 (char *) "self",(char *) "row",(char *) "col", NULL
15183 };
15184
15185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15187 if (SWIG_arg_fail(1)) SWIG_fail;
15188 {
15189 arg2 = static_cast<int >(SWIG_As_int(obj1));
15190 if (SWIG_arg_fail(2)) SWIG_fail;
15191 }
15192 {
15193 arg3 = static_cast<int >(SWIG_As_int(obj2));
15194 if (SWIG_arg_fail(3)) SWIG_fail;
15195 }
15196 {
15197 PyThreadState* __tstate = wxPyBeginAllowThreads();
15198 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15199
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 {
15204 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
15205 }
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = NULL;
15214 wxGrid *arg1 = (wxGrid *) 0 ;
15215 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15216 PyObject * obj0 = 0 ;
15217 PyObject * obj1 = 0 ;
15218 char *kwnames[] = {
15219 (char *) "self",(char *) "editor", NULL
15220 };
15221
15222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15224 if (SWIG_arg_fail(1)) SWIG_fail;
15225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(2)) SWIG_fail;
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 (arg1)->SetDefaultEditor(arg2);
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 Py_INCREF(Py_None); resultobj = Py_None;
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj = NULL;
15243 wxGrid *arg1 = (wxGrid *) 0 ;
15244 int arg2 ;
15245 int arg3 ;
15246 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15247 PyObject * obj0 = 0 ;
15248 PyObject * obj1 = 0 ;
15249 PyObject * obj2 = 0 ;
15250 PyObject * obj3 = 0 ;
15251 char *kwnames[] = {
15252 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15257 if (SWIG_arg_fail(1)) SWIG_fail;
15258 {
15259 arg2 = static_cast<int >(SWIG_As_int(obj1));
15260 if (SWIG_arg_fail(2)) SWIG_fail;
15261 }
15262 {
15263 arg3 = static_cast<int >(SWIG_As_int(obj2));
15264 if (SWIG_arg_fail(3)) SWIG_fail;
15265 }
15266 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15267 if (SWIG_arg_fail(4)) SWIG_fail;
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 (arg1)->SetCellEditor(arg2,arg3,arg4);
15271
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 Py_INCREF(Py_None); resultobj = Py_None;
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj = NULL;
15284 wxGrid *arg1 = (wxGrid *) 0 ;
15285 wxGridCellEditor *result;
15286 PyObject * obj0 = 0 ;
15287 char *kwnames[] = {
15288 (char *) "self", NULL
15289 };
15290
15291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(1)) SWIG_fail;
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15297
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 {
15302 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
15303 }
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15311 PyObject *resultobj = NULL;
15312 wxGrid *arg1 = (wxGrid *) 0 ;
15313 int arg2 ;
15314 int arg3 ;
15315 wxGridCellEditor *result;
15316 PyObject * obj0 = 0 ;
15317 PyObject * obj1 = 0 ;
15318 PyObject * obj2 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self",(char *) "row",(char *) "col", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 arg2 = static_cast<int >(SWIG_As_int(obj1));
15328 if (SWIG_arg_fail(2)) SWIG_fail;
15329 }
15330 {
15331 arg3 = static_cast<int >(SWIG_As_int(obj2));
15332 if (SWIG_arg_fail(3)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 {
15342 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
15343 }
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj = NULL;
15352 wxGrid *arg1 = (wxGrid *) 0 ;
15353 int arg2 ;
15354 int arg3 ;
15355 wxString result;
15356 PyObject * obj0 = 0 ;
15357 PyObject * obj1 = 0 ;
15358 PyObject * obj2 = 0 ;
15359 char *kwnames[] = {
15360 (char *) "self",(char *) "row",(char *) "col", NULL
15361 };
15362
15363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15365 if (SWIG_arg_fail(1)) SWIG_fail;
15366 {
15367 arg2 = static_cast<int >(SWIG_As_int(obj1));
15368 if (SWIG_arg_fail(2)) SWIG_fail;
15369 }
15370 {
15371 arg3 = static_cast<int >(SWIG_As_int(obj2));
15372 if (SWIG_arg_fail(3)) SWIG_fail;
15373 }
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (arg1)->GetCellValue(arg2,arg3);
15377
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 {
15382 #if wxUSE_UNICODE
15383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15384 #else
15385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15386 #endif
15387 }
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj = NULL;
15396 wxGrid *arg1 = (wxGrid *) 0 ;
15397 int arg2 ;
15398 int arg3 ;
15399 wxString *arg4 = 0 ;
15400 bool temp4 = false ;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 PyObject * obj2 = 0 ;
15404 PyObject * obj3 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 {
15413 arg2 = static_cast<int >(SWIG_As_int(obj1));
15414 if (SWIG_arg_fail(2)) SWIG_fail;
15415 }
15416 {
15417 arg3 = static_cast<int >(SWIG_As_int(obj2));
15418 if (SWIG_arg_fail(3)) SWIG_fail;
15419 }
15420 {
15421 arg4 = wxString_in_helper(obj3);
15422 if (arg4 == NULL) SWIG_fail;
15423 temp4 = true;
15424 }
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 Py_INCREF(Py_None); resultobj = Py_None;
15433 {
15434 if (temp4)
15435 delete arg4;
15436 }
15437 return resultobj;
15438 fail:
15439 {
15440 if (temp4)
15441 delete arg4;
15442 }
15443 return NULL;
15444 }
15445
15446
15447 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj = NULL;
15449 wxGrid *arg1 = (wxGrid *) 0 ;
15450 int arg2 ;
15451 int arg3 ;
15452 bool result;
15453 PyObject * obj0 = 0 ;
15454 PyObject * obj1 = 0 ;
15455 PyObject * obj2 = 0 ;
15456 char *kwnames[] = {
15457 (char *) "self",(char *) "row",(char *) "col", NULL
15458 };
15459
15460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(1)) SWIG_fail;
15463 {
15464 arg2 = static_cast<int >(SWIG_As_int(obj1));
15465 if (SWIG_arg_fail(2)) SWIG_fail;
15466 }
15467 {
15468 arg3 = static_cast<int >(SWIG_As_int(obj2));
15469 if (SWIG_arg_fail(3)) SWIG_fail;
15470 }
15471 {
15472 PyThreadState* __tstate = wxPyBeginAllowThreads();
15473 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15474
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 {
15479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15480 }
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = NULL;
15489 wxGrid *arg1 = (wxGrid *) 0 ;
15490 int arg2 ;
15491 int arg3 ;
15492 bool arg4 = (bool) true ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 PyObject * obj2 = 0 ;
15496 PyObject * obj3 = 0 ;
15497 char *kwnames[] = {
15498 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15499 };
15500
15501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15503 if (SWIG_arg_fail(1)) SWIG_fail;
15504 {
15505 arg2 = static_cast<int >(SWIG_As_int(obj1));
15506 if (SWIG_arg_fail(2)) SWIG_fail;
15507 }
15508 {
15509 arg3 = static_cast<int >(SWIG_As_int(obj2));
15510 if (SWIG_arg_fail(3)) SWIG_fail;
15511 }
15512 if (obj3) {
15513 {
15514 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15515 if (SWIG_arg_fail(4)) SWIG_fail;
15516 }
15517 }
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 (arg1)->SetReadOnly(arg2,arg3,arg4);
15521
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 Py_INCREF(Py_None); resultobj = Py_None;
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj = NULL;
15534 wxGrid *arg1 = (wxGrid *) 0 ;
15535 int arg2 ;
15536 bool arg3 = (bool) false ;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 PyObject * obj2 = 0 ;
15540 char *kwnames[] = {
15541 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15542 };
15543
15544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15546 if (SWIG_arg_fail(1)) SWIG_fail;
15547 {
15548 arg2 = static_cast<int >(SWIG_As_int(obj1));
15549 if (SWIG_arg_fail(2)) SWIG_fail;
15550 }
15551 if (obj2) {
15552 {
15553 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15554 if (SWIG_arg_fail(3)) SWIG_fail;
15555 }
15556 }
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 (arg1)->SelectRow(arg2,arg3);
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 Py_INCREF(Py_None); resultobj = Py_None;
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15572 PyObject *resultobj = NULL;
15573 wxGrid *arg1 = (wxGrid *) 0 ;
15574 int arg2 ;
15575 bool arg3 = (bool) false ;
15576 PyObject * obj0 = 0 ;
15577 PyObject * obj1 = 0 ;
15578 PyObject * obj2 = 0 ;
15579 char *kwnames[] = {
15580 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15581 };
15582
15583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15585 if (SWIG_arg_fail(1)) SWIG_fail;
15586 {
15587 arg2 = static_cast<int >(SWIG_As_int(obj1));
15588 if (SWIG_arg_fail(2)) SWIG_fail;
15589 }
15590 if (obj2) {
15591 {
15592 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15593 if (SWIG_arg_fail(3)) SWIG_fail;
15594 }
15595 }
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 (arg1)->SelectCol(arg2,arg3);
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 Py_INCREF(Py_None); resultobj = Py_None;
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj = NULL;
15612 wxGrid *arg1 = (wxGrid *) 0 ;
15613 int arg2 ;
15614 int arg3 ;
15615 int arg4 ;
15616 int arg5 ;
15617 bool arg6 = (bool) false ;
15618 PyObject * obj0 = 0 ;
15619 PyObject * obj1 = 0 ;
15620 PyObject * obj2 = 0 ;
15621 PyObject * obj3 = 0 ;
15622 PyObject * obj4 = 0 ;
15623 PyObject * obj5 = 0 ;
15624 char *kwnames[] = {
15625 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15626 };
15627
15628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15630 if (SWIG_arg_fail(1)) SWIG_fail;
15631 {
15632 arg2 = static_cast<int >(SWIG_As_int(obj1));
15633 if (SWIG_arg_fail(2)) SWIG_fail;
15634 }
15635 {
15636 arg3 = static_cast<int >(SWIG_As_int(obj2));
15637 if (SWIG_arg_fail(3)) SWIG_fail;
15638 }
15639 {
15640 arg4 = static_cast<int >(SWIG_As_int(obj3));
15641 if (SWIG_arg_fail(4)) SWIG_fail;
15642 }
15643 {
15644 arg5 = static_cast<int >(SWIG_As_int(obj4));
15645 if (SWIG_arg_fail(5)) SWIG_fail;
15646 }
15647 if (obj5) {
15648 {
15649 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
15650 if (SWIG_arg_fail(6)) SWIG_fail;
15651 }
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15656
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 Py_INCREF(Py_None); resultobj = Py_None;
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15668 PyObject *resultobj = NULL;
15669 wxGrid *arg1 = (wxGrid *) 0 ;
15670 PyObject * obj0 = 0 ;
15671 char *kwnames[] = {
15672 (char *) "self", NULL
15673 };
15674
15675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15677 if (SWIG_arg_fail(1)) SWIG_fail;
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 (arg1)->SelectAll();
15681
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 Py_INCREF(Py_None); resultobj = Py_None;
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15693 PyObject *resultobj = NULL;
15694 wxGrid *arg1 = (wxGrid *) 0 ;
15695 bool result;
15696 PyObject * obj0 = 0 ;
15697 char *kwnames[] = {
15698 (char *) "self", NULL
15699 };
15700
15701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15703 if (SWIG_arg_fail(1)) SWIG_fail;
15704 {
15705 PyThreadState* __tstate = wxPyBeginAllowThreads();
15706 result = (bool)(arg1)->IsSelection();
15707
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 {
15712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15713 }
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15721 PyObject *resultobj = NULL;
15722 wxGrid *arg1 = (wxGrid *) 0 ;
15723 PyObject * obj0 = 0 ;
15724 char *kwnames[] = {
15725 (char *) "self", NULL
15726 };
15727
15728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15730 if (SWIG_arg_fail(1)) SWIG_fail;
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 (arg1)->ClearSelection();
15734
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 Py_INCREF(Py_None); resultobj = Py_None;
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj = NULL;
15747 wxGrid *arg1 = (wxGrid *) 0 ;
15748 int arg2 ;
15749 int arg3 ;
15750 bool result;
15751 PyObject * obj0 = 0 ;
15752 PyObject * obj1 = 0 ;
15753 PyObject * obj2 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self",(char *) "row",(char *) "col", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 arg2 = static_cast<int >(SWIG_As_int(obj1));
15763 if (SWIG_arg_fail(2)) SWIG_fail;
15764 }
15765 {
15766 arg3 = static_cast<int >(SWIG_As_int(obj2));
15767 if (SWIG_arg_fail(3)) SWIG_fail;
15768 }
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15772
15773 wxPyEndAllowThreads(__tstate);
15774 if (PyErr_Occurred()) SWIG_fail;
15775 }
15776 {
15777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15778 }
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15786 PyObject *resultobj = NULL;
15787 wxGrid *arg1 = (wxGrid *) 0 ;
15788 wxGridCellCoordsArray result;
15789 PyObject * obj0 = 0 ;
15790 char *kwnames[] = {
15791 (char *) "self", NULL
15792 };
15793
15794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15796 if (SWIG_arg_fail(1)) SWIG_fail;
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 result = ((wxGrid const *)arg1)->GetSelectedCells();
15800
15801 wxPyEndAllowThreads(__tstate);
15802 if (PyErr_Occurred()) SWIG_fail;
15803 }
15804 {
15805 resultobj = wxGridCellCoordsArray_helper(result);
15806 }
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15814 PyObject *resultobj = NULL;
15815 wxGrid *arg1 = (wxGrid *) 0 ;
15816 wxGridCellCoordsArray result;
15817 PyObject * obj0 = 0 ;
15818 char *kwnames[] = {
15819 (char *) "self", NULL
15820 };
15821
15822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15828
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = wxGridCellCoordsArray_helper(result);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj = NULL;
15843 wxGrid *arg1 = (wxGrid *) 0 ;
15844 wxGridCellCoordsArray result;
15845 PyObject * obj0 = 0 ;
15846 char *kwnames[] = {
15847 (char *) "self", NULL
15848 };
15849
15850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15852 if (SWIG_arg_fail(1)) SWIG_fail;
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 resultobj = wxGridCellCoordsArray_helper(result);
15862 }
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj = NULL;
15871 wxGrid *arg1 = (wxGrid *) 0 ;
15872 wxArrayInt result;
15873 PyObject * obj0 = 0 ;
15874 char *kwnames[] = {
15875 (char *) "self", NULL
15876 };
15877
15878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15880 if (SWIG_arg_fail(1)) SWIG_fail;
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = ((wxGrid const *)arg1)->GetSelectedRows();
15884
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 {
15889 resultobj = PyList_New(0);
15890 size_t idx;
15891 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15892 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15893 PyList_Append(resultobj, val);
15894 Py_DECREF(val);
15895 }
15896 }
15897 return resultobj;
15898 fail:
15899 return NULL;
15900 }
15901
15902
15903 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15904 PyObject *resultobj = NULL;
15905 wxGrid *arg1 = (wxGrid *) 0 ;
15906 wxArrayInt result;
15907 PyObject * obj0 = 0 ;
15908 char *kwnames[] = {
15909 (char *) "self", NULL
15910 };
15911
15912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15914 if (SWIG_arg_fail(1)) SWIG_fail;
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = ((wxGrid const *)arg1)->GetSelectedCols();
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 {
15923 resultobj = PyList_New(0);
15924 size_t idx;
15925 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15926 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15927 PyList_Append(resultobj, val);
15928 Py_DECREF(val);
15929 }
15930 }
15931 return resultobj;
15932 fail:
15933 return NULL;
15934 }
15935
15936
15937 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15938 PyObject *resultobj = NULL;
15939 wxGrid *arg1 = (wxGrid *) 0 ;
15940 int arg2 ;
15941 PyObject * obj0 = 0 ;
15942 PyObject * obj1 = 0 ;
15943 char *kwnames[] = {
15944 (char *) "self",(char *) "row", NULL
15945 };
15946
15947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
15948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15949 if (SWIG_arg_fail(1)) SWIG_fail;
15950 {
15951 arg2 = static_cast<int >(SWIG_As_int(obj1));
15952 if (SWIG_arg_fail(2)) SWIG_fail;
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 (arg1)->DeselectRow(arg2);
15957
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 Py_INCREF(Py_None); resultobj = Py_None;
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = NULL;
15970 wxGrid *arg1 = (wxGrid *) 0 ;
15971 int arg2 ;
15972 PyObject * obj0 = 0 ;
15973 PyObject * obj1 = 0 ;
15974 char *kwnames[] = {
15975 (char *) "self",(char *) "col", NULL
15976 };
15977
15978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
15979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15980 if (SWIG_arg_fail(1)) SWIG_fail;
15981 {
15982 arg2 = static_cast<int >(SWIG_As_int(obj1));
15983 if (SWIG_arg_fail(2)) SWIG_fail;
15984 }
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 (arg1)->DeselectCol(arg2);
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 Py_INCREF(Py_None); resultobj = Py_None;
15993 return resultobj;
15994 fail:
15995 return NULL;
15996 }
15997
15998
15999 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
16000 PyObject *resultobj = NULL;
16001 wxGrid *arg1 = (wxGrid *) 0 ;
16002 int arg2 ;
16003 int arg3 ;
16004 PyObject * obj0 = 0 ;
16005 PyObject * obj1 = 0 ;
16006 PyObject * obj2 = 0 ;
16007 char *kwnames[] = {
16008 (char *) "self",(char *) "row",(char *) "col", NULL
16009 };
16010
16011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = static_cast<int >(SWIG_As_int(obj2));
16020 if (SWIG_arg_fail(3)) SWIG_fail;
16021 }
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 (arg1)->DeselectCell(arg2,arg3);
16025
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 Py_INCREF(Py_None); resultobj = Py_None;
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = NULL;
16038 wxGrid *arg1 = (wxGrid *) 0 ;
16039 wxGridCellCoords *arg2 = 0 ;
16040 wxGridCellCoords *arg3 = 0 ;
16041 wxRect result;
16042 wxGridCellCoords temp2 ;
16043 wxGridCellCoords temp3 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 PyObject * obj2 = 0 ;
16047 char *kwnames[] = {
16048 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
16049 };
16050
16051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
16052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16053 if (SWIG_arg_fail(1)) SWIG_fail;
16054 {
16055 arg2 = &temp2;
16056 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
16057 }
16058 {
16059 arg3 = &temp3;
16060 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
16061 }
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
16065
16066 wxPyEndAllowThreads(__tstate);
16067 if (PyErr_Occurred()) SWIG_fail;
16068 }
16069 {
16070 wxRect * resultptr;
16071 resultptr = new wxRect(static_cast<wxRect & >(result));
16072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj = NULL;
16082 wxGrid *arg1 = (wxGrid *) 0 ;
16083 wxColour result;
16084 PyObject * obj0 = 0 ;
16085 char *kwnames[] = {
16086 (char *) "self", NULL
16087 };
16088
16089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
16090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16091 if (SWIG_arg_fail(1)) SWIG_fail;
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 result = ((wxGrid const *)arg1)->GetSelectionBackground();
16095
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 {
16100 wxColour * resultptr;
16101 resultptr = new wxColour(static_cast<wxColour & >(result));
16102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
16103 }
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16111 PyObject *resultobj = NULL;
16112 wxGrid *arg1 = (wxGrid *) 0 ;
16113 wxColour result;
16114 PyObject * obj0 = 0 ;
16115 char *kwnames[] = {
16116 (char *) "self", NULL
16117 };
16118
16119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
16120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16121 if (SWIG_arg_fail(1)) SWIG_fail;
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 result = ((wxGrid const *)arg1)->GetSelectionForeground();
16125
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 {
16130 wxColour * resultptr;
16131 resultptr = new wxColour(static_cast<wxColour & >(result));
16132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
16133 }
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj = NULL;
16142 wxGrid *arg1 = (wxGrid *) 0 ;
16143 wxColour *arg2 = 0 ;
16144 wxColour temp2 ;
16145 PyObject * obj0 = 0 ;
16146 PyObject * obj1 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "self",(char *) "c", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 arg2 = &temp2;
16156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16157 }
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 Py_INCREF(Py_None); resultobj = Py_None;
16166 return resultobj;
16167 fail:
16168 return NULL;
16169 }
16170
16171
16172 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16173 PyObject *resultobj = NULL;
16174 wxGrid *arg1 = (wxGrid *) 0 ;
16175 wxColour *arg2 = 0 ;
16176 wxColour temp2 ;
16177 PyObject * obj0 = 0 ;
16178 PyObject * obj1 = 0 ;
16179 char *kwnames[] = {
16180 (char *) "self",(char *) "c", NULL
16181 };
16182
16183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
16188 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16189 }
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16193
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 Py_INCREF(Py_None); resultobj = Py_None;
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = NULL;
16206 wxGrid *arg1 = (wxGrid *) 0 ;
16207 wxString *arg2 = 0 ;
16208 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16209 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16210 bool temp2 = false ;
16211 PyObject * obj0 = 0 ;
16212 PyObject * obj1 = 0 ;
16213 PyObject * obj2 = 0 ;
16214 PyObject * obj3 = 0 ;
16215 char *kwnames[] = {
16216 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16217 };
16218
16219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16221 if (SWIG_arg_fail(1)) SWIG_fail;
16222 {
16223 arg2 = wxString_in_helper(obj1);
16224 if (arg2 == NULL) SWIG_fail;
16225 temp2 = true;
16226 }
16227 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16228 if (SWIG_arg_fail(3)) SWIG_fail;
16229 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16230 if (SWIG_arg_fail(4)) SWIG_fail;
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16234
16235 wxPyEndAllowThreads(__tstate);
16236 if (PyErr_Occurred()) SWIG_fail;
16237 }
16238 Py_INCREF(Py_None); resultobj = Py_None;
16239 {
16240 if (temp2)
16241 delete arg2;
16242 }
16243 return resultobj;
16244 fail:
16245 {
16246 if (temp2)
16247 delete arg2;
16248 }
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj = NULL;
16255 wxGrid *arg1 = (wxGrid *) 0 ;
16256 int arg2 ;
16257 int arg3 ;
16258 wxGridCellEditor *result;
16259 PyObject * obj0 = 0 ;
16260 PyObject * obj1 = 0 ;
16261 PyObject * obj2 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self",(char *) "row",(char *) "col", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 arg2 = static_cast<int >(SWIG_As_int(obj1));
16271 if (SWIG_arg_fail(2)) SWIG_fail;
16272 }
16273 {
16274 arg3 = static_cast<int >(SWIG_As_int(obj2));
16275 if (SWIG_arg_fail(3)) SWIG_fail;
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16280
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 {
16285 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16286 }
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj = NULL;
16295 wxGrid *arg1 = (wxGrid *) 0 ;
16296 int arg2 ;
16297 int arg3 ;
16298 wxGridCellRenderer *result;
16299 PyObject * obj0 = 0 ;
16300 PyObject * obj1 = 0 ;
16301 PyObject * obj2 = 0 ;
16302 char *kwnames[] = {
16303 (char *) "self",(char *) "row",(char *) "col", NULL
16304 };
16305
16306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16308 if (SWIG_arg_fail(1)) SWIG_fail;
16309 {
16310 arg2 = static_cast<int >(SWIG_As_int(obj1));
16311 if (SWIG_arg_fail(2)) SWIG_fail;
16312 }
16313 {
16314 arg3 = static_cast<int >(SWIG_As_int(obj2));
16315 if (SWIG_arg_fail(3)) SWIG_fail;
16316 }
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16320
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 {
16325 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16326 }
16327 return resultobj;
16328 fail:
16329 return NULL;
16330 }
16331
16332
16333 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16334 PyObject *resultobj = NULL;
16335 wxGrid *arg1 = (wxGrid *) 0 ;
16336 wxString *arg2 = 0 ;
16337 wxGridCellEditor *result;
16338 bool temp2 = false ;
16339 PyObject * obj0 = 0 ;
16340 PyObject * obj1 = 0 ;
16341 char *kwnames[] = {
16342 (char *) "self",(char *) "typeName", NULL
16343 };
16344
16345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16347 if (SWIG_arg_fail(1)) SWIG_fail;
16348 {
16349 arg2 = wxString_in_helper(obj1);
16350 if (arg2 == NULL) SWIG_fail;
16351 temp2 = true;
16352 }
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16356
16357 wxPyEndAllowThreads(__tstate);
16358 if (PyErr_Occurred()) SWIG_fail;
16359 }
16360 {
16361 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16362 }
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return resultobj;
16368 fail:
16369 {
16370 if (temp2)
16371 delete arg2;
16372 }
16373 return NULL;
16374 }
16375
16376
16377 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16378 PyObject *resultobj = NULL;
16379 wxGrid *arg1 = (wxGrid *) 0 ;
16380 wxString *arg2 = 0 ;
16381 wxGridCellRenderer *result;
16382 bool temp2 = false ;
16383 PyObject * obj0 = 0 ;
16384 PyObject * obj1 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "self",(char *) "typeName", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16391 if (SWIG_arg_fail(1)) SWIG_fail;
16392 {
16393 arg2 = wxString_in_helper(obj1);
16394 if (arg2 == NULL) SWIG_fail;
16395 temp2 = true;
16396 }
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16400
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16406 }
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return resultobj;
16412 fail:
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj = NULL;
16423 wxGrid *arg1 = (wxGrid *) 0 ;
16424 int arg2 ;
16425 int arg3 ;
16426 PyObject * obj0 = 0 ;
16427 PyObject * obj1 = 0 ;
16428 PyObject * obj2 = 0 ;
16429 char *kwnames[] = {
16430 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16431 };
16432
16433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16435 if (SWIG_arg_fail(1)) SWIG_fail;
16436 {
16437 arg2 = static_cast<int >(SWIG_As_int(obj1));
16438 if (SWIG_arg_fail(2)) SWIG_fail;
16439 }
16440 {
16441 arg3 = static_cast<int >(SWIG_As_int(obj2));
16442 if (SWIG_arg_fail(3)) SWIG_fail;
16443 }
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 (arg1)->SetMargins(arg2,arg3);
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 Py_INCREF(Py_None); resultobj = Py_None;
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj = NULL;
16460 wxGrid *arg1 = (wxGrid *) 0 ;
16461 wxWindow *result;
16462 PyObject * obj0 = 0 ;
16463 char *kwnames[] = {
16464 (char *) "self", NULL
16465 };
16466
16467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16469 if (SWIG_arg_fail(1)) SWIG_fail;
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (wxWindow *)(arg1)->GetGridWindow();
16473
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 {
16478 resultobj = wxPyMake_wxObject(result, 0);
16479 }
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj = NULL;
16488 wxGrid *arg1 = (wxGrid *) 0 ;
16489 wxWindow *result;
16490 PyObject * obj0 = 0 ;
16491 char *kwnames[] = {
16492 (char *) "self", NULL
16493 };
16494
16495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16497 if (SWIG_arg_fail(1)) SWIG_fail;
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16501
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 {
16506 resultobj = wxPyMake_wxObject(result, 0);
16507 }
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = NULL;
16516 wxGrid *arg1 = (wxGrid *) 0 ;
16517 wxWindow *result;
16518 PyObject * obj0 = 0 ;
16519 char *kwnames[] = {
16520 (char *) "self", NULL
16521 };
16522
16523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16525 if (SWIG_arg_fail(1)) SWIG_fail;
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16529
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 {
16534 resultobj = wxPyMake_wxObject(result, 0);
16535 }
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj = NULL;
16544 wxGrid *arg1 = (wxGrid *) 0 ;
16545 wxWindow *result;
16546 PyObject * obj0 = 0 ;
16547 char *kwnames[] = {
16548 (char *) "self", NULL
16549 };
16550
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16553 if (SWIG_arg_fail(1)) SWIG_fail;
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 {
16562 resultobj = wxPyMake_wxObject(result, 0);
16563 }
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj = NULL;
16572 wxGrid *arg1 = (wxGrid *) 0 ;
16573 int arg2 ;
16574 PyObject * obj0 = 0 ;
16575 PyObject * obj1 = 0 ;
16576 char *kwnames[] = {
16577 (char *) "self",(char *) "x", NULL
16578 };
16579
16580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 {
16584 arg2 = static_cast<int >(SWIG_As_int(obj1));
16585 if (SWIG_arg_fail(2)) SWIG_fail;
16586 }
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 (arg1)->SetScrollLineX(arg2);
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 Py_INCREF(Py_None); resultobj = Py_None;
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16602 PyObject *resultobj = NULL;
16603 wxGrid *arg1 = (wxGrid *) 0 ;
16604 int arg2 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 char *kwnames[] = {
16608 (char *) "self",(char *) "y", NULL
16609 };
16610
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16613 if (SWIG_arg_fail(1)) SWIG_fail;
16614 {
16615 arg2 = static_cast<int >(SWIG_As_int(obj1));
16616 if (SWIG_arg_fail(2)) SWIG_fail;
16617 }
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 (arg1)->SetScrollLineY(arg2);
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 Py_INCREF(Py_None); resultobj = Py_None;
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = NULL;
16634 wxGrid *arg1 = (wxGrid *) 0 ;
16635 int result;
16636 PyObject * obj0 = 0 ;
16637 char *kwnames[] = {
16638 (char *) "self", NULL
16639 };
16640
16641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16643 if (SWIG_arg_fail(1)) SWIG_fail;
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16647
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = SWIG_From_int(static_cast<int >(result));
16653 }
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj = NULL;
16662 wxGrid *arg1 = (wxGrid *) 0 ;
16663 int result;
16664 PyObject * obj0 = 0 ;
16665 char *kwnames[] = {
16666 (char *) "self", NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16671 if (SWIG_arg_fail(1)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16675
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 {
16680 resultobj = SWIG_From_int(static_cast<int >(result));
16681 }
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj = NULL;
16690 wxGrid *arg1 = (wxGrid *) 0 ;
16691 int arg2 ;
16692 int result;
16693 PyObject * obj0 = 0 ;
16694 PyObject * obj1 = 0 ;
16695 char *kwnames[] = {
16696 (char *) "self",(char *) "x", NULL
16697 };
16698
16699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16701 if (SWIG_arg_fail(1)) SWIG_fail;
16702 {
16703 arg2 = static_cast<int >(SWIG_As_int(obj1));
16704 if (SWIG_arg_fail(2)) SWIG_fail;
16705 }
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 resultobj = SWIG_From_int(static_cast<int >(result));
16715 }
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = NULL;
16724 wxGrid *arg1 = (wxGrid *) 0 ;
16725 int arg2 ;
16726 int result;
16727 PyObject * obj0 = 0 ;
16728 PyObject * obj1 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self",(char *) "y", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<int >(SWIG_As_int(obj1));
16738 if (SWIG_arg_fail(2)) SWIG_fail;
16739 }
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 {
16748 resultobj = SWIG_From_int(static_cast<int >(result));
16749 }
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj = NULL;
16758 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16759 wxVisualAttributes result;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "variant", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16766 if (obj0) {
16767 {
16768 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
16769 if (SWIG_arg_fail(1)) SWIG_fail;
16770 }
16771 }
16772 {
16773 if (!wxPyCheckForApp()) SWIG_fail;
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 result = wxGrid::GetClassDefaultAttributes(arg1);
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 {
16781 wxVisualAttributes * resultptr;
16782 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
16783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16784 }
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16792 PyObject *obj;
16793 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16794 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16795 Py_INCREF(obj);
16796 return Py_BuildValue((char *)"");
16797 }
16798 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16799 PyObject *resultobj = NULL;
16800 int arg1 ;
16801 wxEventType arg2 ;
16802 wxGrid *arg3 = (wxGrid *) 0 ;
16803 int arg4 = (int) -1 ;
16804 int arg5 = (int) -1 ;
16805 int arg6 = (int) -1 ;
16806 int arg7 = (int) -1 ;
16807 bool arg8 = (bool) true ;
16808 bool arg9 = (bool) false ;
16809 bool arg10 = (bool) false ;
16810 bool arg11 = (bool) false ;
16811 bool arg12 = (bool) false ;
16812 wxGridEvent *result;
16813 PyObject * obj0 = 0 ;
16814 PyObject * obj1 = 0 ;
16815 PyObject * obj2 = 0 ;
16816 PyObject * obj3 = 0 ;
16817 PyObject * obj4 = 0 ;
16818 PyObject * obj5 = 0 ;
16819 PyObject * obj6 = 0 ;
16820 PyObject * obj7 = 0 ;
16821 PyObject * obj8 = 0 ;
16822 PyObject * obj9 = 0 ;
16823 PyObject * obj10 = 0 ;
16824 PyObject * obj11 = 0 ;
16825 char *kwnames[] = {
16826 (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
16827 };
16828
16829 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;
16830 {
16831 arg1 = static_cast<int >(SWIG_As_int(obj0));
16832 if (SWIG_arg_fail(1)) SWIG_fail;
16833 }
16834 {
16835 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
16836 if (SWIG_arg_fail(2)) SWIG_fail;
16837 }
16838 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16839 if (SWIG_arg_fail(3)) SWIG_fail;
16840 if (obj3) {
16841 {
16842 arg4 = static_cast<int >(SWIG_As_int(obj3));
16843 if (SWIG_arg_fail(4)) SWIG_fail;
16844 }
16845 }
16846 if (obj4) {
16847 {
16848 arg5 = static_cast<int >(SWIG_As_int(obj4));
16849 if (SWIG_arg_fail(5)) SWIG_fail;
16850 }
16851 }
16852 if (obj5) {
16853 {
16854 arg6 = static_cast<int >(SWIG_As_int(obj5));
16855 if (SWIG_arg_fail(6)) SWIG_fail;
16856 }
16857 }
16858 if (obj6) {
16859 {
16860 arg7 = static_cast<int >(SWIG_As_int(obj6));
16861 if (SWIG_arg_fail(7)) SWIG_fail;
16862 }
16863 }
16864 if (obj7) {
16865 {
16866 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
16867 if (SWIG_arg_fail(8)) SWIG_fail;
16868 }
16869 }
16870 if (obj8) {
16871 {
16872 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
16873 if (SWIG_arg_fail(9)) SWIG_fail;
16874 }
16875 }
16876 if (obj9) {
16877 {
16878 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
16879 if (SWIG_arg_fail(10)) SWIG_fail;
16880 }
16881 }
16882 if (obj10) {
16883 {
16884 arg11 = static_cast<bool >(SWIG_As_bool(obj10));
16885 if (SWIG_arg_fail(11)) SWIG_fail;
16886 }
16887 }
16888 if (obj11) {
16889 {
16890 arg12 = static_cast<bool >(SWIG_As_bool(obj11));
16891 if (SWIG_arg_fail(12)) SWIG_fail;
16892 }
16893 }
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16897
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj = NULL;
16910 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16911 int result;
16912 PyObject * obj0 = 0 ;
16913 char *kwnames[] = {
16914 (char *) "self", NULL
16915 };
16916
16917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16919 if (SWIG_arg_fail(1)) SWIG_fail;
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (int)(arg1)->GetRow();
16923
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 {
16928 resultobj = SWIG_From_int(static_cast<int >(result));
16929 }
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj = NULL;
16938 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16939 int result;
16940 PyObject * obj0 = 0 ;
16941 char *kwnames[] = {
16942 (char *) "self", NULL
16943 };
16944
16945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
16946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16947 if (SWIG_arg_fail(1)) SWIG_fail;
16948 {
16949 PyThreadState* __tstate = wxPyBeginAllowThreads();
16950 result = (int)(arg1)->GetCol();
16951
16952 wxPyEndAllowThreads(__tstate);
16953 if (PyErr_Occurred()) SWIG_fail;
16954 }
16955 {
16956 resultobj = SWIG_From_int(static_cast<int >(result));
16957 }
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj = NULL;
16966 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16967 wxPoint result;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "self", NULL
16971 };
16972
16973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
16974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16975 if (SWIG_arg_fail(1)) SWIG_fail;
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (arg1)->GetPosition();
16979
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 {
16984 wxPoint * resultptr;
16985 resultptr = new wxPoint(static_cast<wxPoint & >(result));
16986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16987 }
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj = NULL;
16996 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16997 bool result;
16998 PyObject * obj0 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "self", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
17004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17005 if (SWIG_arg_fail(1)) SWIG_fail;
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 result = (bool)(arg1)->Selecting();
17009
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 {
17014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17015 }
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj = NULL;
17024 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17025 bool result;
17026 PyObject * obj0 = 0 ;
17027 char *kwnames[] = {
17028 (char *) "self", NULL
17029 };
17030
17031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
17032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17033 if (SWIG_arg_fail(1)) SWIG_fail;
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (bool)(arg1)->ControlDown();
17037
17038 wxPyEndAllowThreads(__tstate);
17039 if (PyErr_Occurred()) SWIG_fail;
17040 }
17041 {
17042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17043 }
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj = NULL;
17052 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17053 bool result;
17054 PyObject * obj0 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 result = (bool)(arg1)->MetaDown();
17065
17066 wxPyEndAllowThreads(__tstate);
17067 if (PyErr_Occurred()) SWIG_fail;
17068 }
17069 {
17070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17071 }
17072 return resultobj;
17073 fail:
17074 return NULL;
17075 }
17076
17077
17078 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17079 PyObject *resultobj = NULL;
17080 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17081 bool result;
17082 PyObject * obj0 = 0 ;
17083 char *kwnames[] = {
17084 (char *) "self", NULL
17085 };
17086
17087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
17088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17089 if (SWIG_arg_fail(1)) SWIG_fail;
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (bool)(arg1)->ShiftDown();
17093
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 {
17098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17099 }
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj = NULL;
17108 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17109 bool result;
17110 PyObject * obj0 = 0 ;
17111 char *kwnames[] = {
17112 (char *) "self", NULL
17113 };
17114
17115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
17116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17117 if (SWIG_arg_fail(1)) SWIG_fail;
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 result = (bool)(arg1)->AltDown();
17121
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 {
17126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17127 }
17128 return resultobj;
17129 fail:
17130 return NULL;
17131 }
17132
17133
17134 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
17135 PyObject *obj;
17136 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17137 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
17138 Py_INCREF(obj);
17139 return Py_BuildValue((char *)"");
17140 }
17141 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17142 PyObject *resultobj = NULL;
17143 int arg1 ;
17144 wxEventType arg2 ;
17145 wxGrid *arg3 = (wxGrid *) 0 ;
17146 int arg4 = (int) -1 ;
17147 int arg5 = (int) -1 ;
17148 int arg6 = (int) -1 ;
17149 bool arg7 = (bool) false ;
17150 bool arg8 = (bool) false ;
17151 bool arg9 = (bool) false ;
17152 bool arg10 = (bool) false ;
17153 wxGridSizeEvent *result;
17154 PyObject * obj0 = 0 ;
17155 PyObject * obj1 = 0 ;
17156 PyObject * obj2 = 0 ;
17157 PyObject * obj3 = 0 ;
17158 PyObject * obj4 = 0 ;
17159 PyObject * obj5 = 0 ;
17160 PyObject * obj6 = 0 ;
17161 PyObject * obj7 = 0 ;
17162 PyObject * obj8 = 0 ;
17163 PyObject * obj9 = 0 ;
17164 char *kwnames[] = {
17165 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17166 };
17167
17168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17169 {
17170 arg1 = static_cast<int >(SWIG_As_int(obj0));
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 }
17173 {
17174 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17175 if (SWIG_arg_fail(2)) SWIG_fail;
17176 }
17177 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17178 if (SWIG_arg_fail(3)) SWIG_fail;
17179 if (obj3) {
17180 {
17181 arg4 = static_cast<int >(SWIG_As_int(obj3));
17182 if (SWIG_arg_fail(4)) SWIG_fail;
17183 }
17184 }
17185 if (obj4) {
17186 {
17187 arg5 = static_cast<int >(SWIG_As_int(obj4));
17188 if (SWIG_arg_fail(5)) SWIG_fail;
17189 }
17190 }
17191 if (obj5) {
17192 {
17193 arg6 = static_cast<int >(SWIG_As_int(obj5));
17194 if (SWIG_arg_fail(6)) SWIG_fail;
17195 }
17196 }
17197 if (obj6) {
17198 {
17199 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
17200 if (SWIG_arg_fail(7)) SWIG_fail;
17201 }
17202 }
17203 if (obj7) {
17204 {
17205 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
17206 if (SWIG_arg_fail(8)) SWIG_fail;
17207 }
17208 }
17209 if (obj8) {
17210 {
17211 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
17212 if (SWIG_arg_fail(9)) SWIG_fail;
17213 }
17214 }
17215 if (obj9) {
17216 {
17217 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
17218 if (SWIG_arg_fail(10)) SWIG_fail;
17219 }
17220 }
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17224
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17236 PyObject *resultobj = NULL;
17237 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17238 int result;
17239 PyObject * obj0 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self", NULL
17242 };
17243
17244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17246 if (SWIG_arg_fail(1)) SWIG_fail;
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 result = (int)(arg1)->GetRowOrCol();
17250
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 {
17255 resultobj = SWIG_From_int(static_cast<int >(result));
17256 }
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj = NULL;
17265 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17266 wxPoint result;
17267 PyObject * obj0 = 0 ;
17268 char *kwnames[] = {
17269 (char *) "self", NULL
17270 };
17271
17272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17274 if (SWIG_arg_fail(1)) SWIG_fail;
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 result = (arg1)->GetPosition();
17278
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 {
17283 wxPoint * resultptr;
17284 resultptr = new wxPoint(static_cast<wxPoint & >(result));
17285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17286 }
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj = NULL;
17295 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17296 bool result;
17297 PyObject * obj0 = 0 ;
17298 char *kwnames[] = {
17299 (char *) "self", NULL
17300 };
17301
17302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17304 if (SWIG_arg_fail(1)) SWIG_fail;
17305 {
17306 PyThreadState* __tstate = wxPyBeginAllowThreads();
17307 result = (bool)(arg1)->ControlDown();
17308
17309 wxPyEndAllowThreads(__tstate);
17310 if (PyErr_Occurred()) SWIG_fail;
17311 }
17312 {
17313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17314 }
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17322 PyObject *resultobj = NULL;
17323 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17324 bool result;
17325 PyObject * obj0 = 0 ;
17326 char *kwnames[] = {
17327 (char *) "self", NULL
17328 };
17329
17330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17332 if (SWIG_arg_fail(1)) SWIG_fail;
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (bool)(arg1)->MetaDown();
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 {
17341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17342 }
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj = NULL;
17351 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17352 bool result;
17353 PyObject * obj0 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (bool)(arg1)->ShiftDown();
17364
17365 wxPyEndAllowThreads(__tstate);
17366 if (PyErr_Occurred()) SWIG_fail;
17367 }
17368 {
17369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj = NULL;
17379 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17380 bool result;
17381 PyObject * obj0 = 0 ;
17382 char *kwnames[] = {
17383 (char *) "self", NULL
17384 };
17385
17386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17388 if (SWIG_arg_fail(1)) SWIG_fail;
17389 {
17390 PyThreadState* __tstate = wxPyBeginAllowThreads();
17391 result = (bool)(arg1)->AltDown();
17392
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 {
17397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17398 }
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17406 PyObject *obj;
17407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17408 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17409 Py_INCREF(obj);
17410 return Py_BuildValue((char *)"");
17411 }
17412 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj = NULL;
17414 int arg1 ;
17415 wxEventType arg2 ;
17416 wxGrid *arg3 = (wxGrid *) 0 ;
17417 wxGridCellCoords *arg4 = 0 ;
17418 wxGridCellCoords *arg5 = 0 ;
17419 bool arg6 = (bool) true ;
17420 bool arg7 = (bool) false ;
17421 bool arg8 = (bool) false ;
17422 bool arg9 = (bool) false ;
17423 bool arg10 = (bool) false ;
17424 wxGridRangeSelectEvent *result;
17425 wxGridCellCoords temp4 ;
17426 wxGridCellCoords temp5 ;
17427 PyObject * obj0 = 0 ;
17428 PyObject * obj1 = 0 ;
17429 PyObject * obj2 = 0 ;
17430 PyObject * obj3 = 0 ;
17431 PyObject * obj4 = 0 ;
17432 PyObject * obj5 = 0 ;
17433 PyObject * obj6 = 0 ;
17434 PyObject * obj7 = 0 ;
17435 PyObject * obj8 = 0 ;
17436 PyObject * obj9 = 0 ;
17437 char *kwnames[] = {
17438 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17439 };
17440
17441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17442 {
17443 arg1 = static_cast<int >(SWIG_As_int(obj0));
17444 if (SWIG_arg_fail(1)) SWIG_fail;
17445 }
17446 {
17447 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17448 if (SWIG_arg_fail(2)) SWIG_fail;
17449 }
17450 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(3)) SWIG_fail;
17452 {
17453 arg4 = &temp4;
17454 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17455 }
17456 {
17457 arg5 = &temp5;
17458 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17459 }
17460 if (obj5) {
17461 {
17462 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
17463 if (SWIG_arg_fail(6)) SWIG_fail;
17464 }
17465 }
17466 if (obj6) {
17467 {
17468 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
17469 if (SWIG_arg_fail(7)) SWIG_fail;
17470 }
17471 }
17472 if (obj7) {
17473 {
17474 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
17475 if (SWIG_arg_fail(8)) SWIG_fail;
17476 }
17477 }
17478 if (obj8) {
17479 {
17480 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
17481 if (SWIG_arg_fail(9)) SWIG_fail;
17482 }
17483 }
17484 if (obj9) {
17485 {
17486 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
17487 if (SWIG_arg_fail(10)) SWIG_fail;
17488 }
17489 }
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17493
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17498 return resultobj;
17499 fail:
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj = NULL;
17506 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17507 wxGridCellCoords result;
17508 PyObject * obj0 = 0 ;
17509 char *kwnames[] = {
17510 (char *) "self", NULL
17511 };
17512
17513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17515 if (SWIG_arg_fail(1)) SWIG_fail;
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (arg1)->GetTopLeftCoords();
17519
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 {
17524 wxGridCellCoords * resultptr;
17525 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
17526 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17527 }
17528 return resultobj;
17529 fail:
17530 return NULL;
17531 }
17532
17533
17534 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17535 PyObject *resultobj = NULL;
17536 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17537 wxGridCellCoords result;
17538 PyObject * obj0 = 0 ;
17539 char *kwnames[] = {
17540 (char *) "self", NULL
17541 };
17542
17543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17545 if (SWIG_arg_fail(1)) SWIG_fail;
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (arg1)->GetBottomRightCoords();
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 wxGridCellCoords * resultptr;
17555 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
17556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17557 }
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = NULL;
17566 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17567 int result;
17568 PyObject * obj0 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 result = (int)(arg1)->GetTopRow();
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 {
17584 resultobj = SWIG_From_int(static_cast<int >(result));
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj = NULL;
17594 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17595 int result;
17596 PyObject * obj0 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (int)(arg1)->GetBottomRow();
17607
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = SWIG_From_int(static_cast<int >(result));
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17621 PyObject *resultobj = NULL;
17622 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17623 int result;
17624 PyObject * obj0 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "self", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (int)(arg1)->GetLeftCol();
17635
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 {
17640 resultobj = SWIG_From_int(static_cast<int >(result));
17641 }
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj = NULL;
17650 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17651 int result;
17652 PyObject * obj0 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 {
17661 PyThreadState* __tstate = wxPyBeginAllowThreads();
17662 result = (int)(arg1)->GetRightCol();
17663
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 {
17668 resultobj = SWIG_From_int(static_cast<int >(result));
17669 }
17670 return resultobj;
17671 fail:
17672 return NULL;
17673 }
17674
17675
17676 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj = NULL;
17678 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17679 bool result;
17680 PyObject * obj0 = 0 ;
17681 char *kwnames[] = {
17682 (char *) "self", NULL
17683 };
17684
17685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17687 if (SWIG_arg_fail(1)) SWIG_fail;
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 result = (bool)(arg1)->Selecting();
17691
17692 wxPyEndAllowThreads(__tstate);
17693 if (PyErr_Occurred()) SWIG_fail;
17694 }
17695 {
17696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17697 }
17698 return resultobj;
17699 fail:
17700 return NULL;
17701 }
17702
17703
17704 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17705 PyObject *resultobj = NULL;
17706 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17707 bool result;
17708 PyObject * obj0 = 0 ;
17709 char *kwnames[] = {
17710 (char *) "self", NULL
17711 };
17712
17713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17715 if (SWIG_arg_fail(1)) SWIG_fail;
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 result = (bool)(arg1)->ControlDown();
17719
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 {
17724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17725 }
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj = NULL;
17734 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17735 bool result;
17736 PyObject * obj0 = 0 ;
17737 char *kwnames[] = {
17738 (char *) "self", NULL
17739 };
17740
17741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17743 if (SWIG_arg_fail(1)) SWIG_fail;
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->MetaDown();
17747
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = NULL;
17762 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17763 bool result;
17764 PyObject * obj0 = 0 ;
17765 char *kwnames[] = {
17766 (char *) "self", NULL
17767 };
17768
17769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17771 if (SWIG_arg_fail(1)) SWIG_fail;
17772 {
17773 PyThreadState* __tstate = wxPyBeginAllowThreads();
17774 result = (bool)(arg1)->ShiftDown();
17775
17776 wxPyEndAllowThreads(__tstate);
17777 if (PyErr_Occurred()) SWIG_fail;
17778 }
17779 {
17780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17781 }
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17789 PyObject *resultobj = NULL;
17790 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17791 bool result;
17792 PyObject * obj0 = 0 ;
17793 char *kwnames[] = {
17794 (char *) "self", NULL
17795 };
17796
17797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17799 if (SWIG_arg_fail(1)) SWIG_fail;
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 result = (bool)(arg1)->AltDown();
17803
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 {
17808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17817 PyObject *obj;
17818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17819 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17820 Py_INCREF(obj);
17821 return Py_BuildValue((char *)"");
17822 }
17823 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj = NULL;
17825 int arg1 ;
17826 wxEventType arg2 ;
17827 wxObject *arg3 = (wxObject *) 0 ;
17828 int arg4 ;
17829 int arg5 ;
17830 wxControl *arg6 = (wxControl *) 0 ;
17831 wxGridEditorCreatedEvent *result;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 PyObject * obj2 = 0 ;
17835 PyObject * obj3 = 0 ;
17836 PyObject * obj4 = 0 ;
17837 PyObject * obj5 = 0 ;
17838 char *kwnames[] = {
17839 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17840 };
17841
17842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17843 {
17844 arg1 = static_cast<int >(SWIG_As_int(obj0));
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 }
17847 {
17848 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17849 if (SWIG_arg_fail(2)) SWIG_fail;
17850 }
17851 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17852 if (SWIG_arg_fail(3)) SWIG_fail;
17853 {
17854 arg4 = static_cast<int >(SWIG_As_int(obj3));
17855 if (SWIG_arg_fail(4)) SWIG_fail;
17856 }
17857 {
17858 arg5 = static_cast<int >(SWIG_As_int(obj4));
17859 if (SWIG_arg_fail(5)) SWIG_fail;
17860 }
17861 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17862 if (SWIG_arg_fail(6)) SWIG_fail;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17878 PyObject *resultobj = NULL;
17879 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17880 int result;
17881 PyObject * obj0 = 0 ;
17882 char *kwnames[] = {
17883 (char *) "self", NULL
17884 };
17885
17886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17888 if (SWIG_arg_fail(1)) SWIG_fail;
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (int)(arg1)->GetRow();
17892
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 resultobj = SWIG_From_int(static_cast<int >(result));
17898 }
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj = NULL;
17907 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17908 int result;
17909 PyObject * obj0 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(1)) SWIG_fail;
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (int)(arg1)->GetCol();
17920
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 resultobj = SWIG_From_int(static_cast<int >(result));
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj = NULL;
17935 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17936 wxControl *result;
17937 PyObject * obj0 = 0 ;
17938 char *kwnames[] = {
17939 (char *) "self", NULL
17940 };
17941
17942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
17943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17944 if (SWIG_arg_fail(1)) SWIG_fail;
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = (wxControl *)(arg1)->GetControl();
17948
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 {
17953 resultobj = wxPyMake_wxObject(result, 0);
17954 }
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = NULL;
17963 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17964 int arg2 ;
17965 PyObject * obj0 = 0 ;
17966 PyObject * obj1 = 0 ;
17967 char *kwnames[] = {
17968 (char *) "self",(char *) "row", NULL
17969 };
17970
17971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
17972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17973 if (SWIG_arg_fail(1)) SWIG_fail;
17974 {
17975 arg2 = static_cast<int >(SWIG_As_int(obj1));
17976 if (SWIG_arg_fail(2)) SWIG_fail;
17977 }
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 (arg1)->SetRow(arg2);
17981
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 Py_INCREF(Py_None); resultobj = Py_None;
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17993 PyObject *resultobj = NULL;
17994 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17995 int arg2 ;
17996 PyObject * obj0 = 0 ;
17997 PyObject * obj1 = 0 ;
17998 char *kwnames[] = {
17999 (char *) "self",(char *) "col", NULL
18000 };
18001
18002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
18003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18004 if (SWIG_arg_fail(1)) SWIG_fail;
18005 {
18006 arg2 = static_cast<int >(SWIG_As_int(obj1));
18007 if (SWIG_arg_fail(2)) SWIG_fail;
18008 }
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 (arg1)->SetCol(arg2);
18012
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 Py_INCREF(Py_None); resultobj = Py_None;
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj = NULL;
18025 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
18026 wxControl *arg2 = (wxControl *) 0 ;
18027 PyObject * obj0 = 0 ;
18028 PyObject * obj1 = 0 ;
18029 char *kwnames[] = {
18030 (char *) "self",(char *) "ctrl", NULL
18031 };
18032
18033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
18034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18035 if (SWIG_arg_fail(1)) SWIG_fail;
18036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
18037 if (SWIG_arg_fail(2)) SWIG_fail;
18038 {
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 (arg1)->SetControl(arg2);
18041
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 Py_INCREF(Py_None); resultobj = Py_None;
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
18053 PyObject *obj;
18054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18055 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
18056 Py_INCREF(obj);
18057 return Py_BuildValue((char *)"");
18058 }
18059 static PyMethodDef SwigMethods[] = {
18060 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18061 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18062 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18063 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18064 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
18065 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
18066 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18067 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
18068 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18069 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18070 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18071 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
18072 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18073 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
18074 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18075 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
18076 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18077 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18078 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18079 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
18080 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
18081 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
18082 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18083 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
18084 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18085 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
18086 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18087 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
18088 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18089 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
18090 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18091 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
18092 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18093 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18094 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18095 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18096 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18097 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18098 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18099 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18100 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
18101 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
18102 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
18103 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18104 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18105 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
18106 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18107 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
18108 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
18109 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
18110 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
18111 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18112 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
18113 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18114 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18115 { (char *)"PyGridCellEditor_SetSize", (PyCFunction) _wrap_PyGridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18116 { (char *)"PyGridCellEditor_Show", (PyCFunction) _wrap_PyGridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
18117 { (char *)"PyGridCellEditor_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18118 { (char *)"PyGridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
18119 { (char *)"PyGridCellEditor_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
18120 { (char *)"PyGridCellEditor_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
18121 { (char *)"PyGridCellEditor_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
18122 { (char *)"PyGridCellEditor_Destroy", (PyCFunction) _wrap_PyGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18123 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18124 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
18125 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18126 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18127 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
18128 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
18131 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18132 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
18134 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18135 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18136 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
18137 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18138 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
18140 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
18143 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
18146 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18148 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
18150 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18152 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18154 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18177 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18182 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18189 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18191 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18192 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18195 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18198 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18201 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18204 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18207 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18210 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18234 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"PyGridTableBase_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"PyGridTableBase_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"PyGridTableBase_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"PyGridTableBase_Clear", (PyCFunction) _wrap_PyGridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"PyGridTableBase_InsertRows", (PyCFunction) _wrap_PyGridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"PyGridTableBase_AppendRows", (PyCFunction) _wrap_PyGridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"PyGridTableBase_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"PyGridTableBase_InsertCols", (PyCFunction) _wrap_PyGridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"PyGridTableBase_AppendCols", (PyCFunction) _wrap_PyGridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18246 { (char *)"PyGridTableBase_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"PyGridTableBase_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"PyGridTableBase_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"PyGridTableBase_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"PyGridTableBase_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"PyGridTableBase_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"PyGridTableBase_GetAttr", (PyCFunction) _wrap_PyGridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"PyGridTableBase_SetAttr", (PyCFunction) _wrap_PyGridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"PyGridTableBase_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18255 { (char *)"PyGridTableBase_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18257 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18259 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18262 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18270 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18281 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18298 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18321 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18323 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18325 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18328 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18329 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18334 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18335 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18338 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18339 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18343 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18345 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18346 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18347 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18348 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18356 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18358 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18359 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18360 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18364 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18365 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18366 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18367 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18368 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18369 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18370 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18371 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18372 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18373 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18374 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18375 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18376 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18377 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18378 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18379 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18380 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18381 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18382 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18383 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18384 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18385 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18386 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18387 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18388 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18389 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18390 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18391 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18392 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18393 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18394 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18395 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18396 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18397 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18398 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18399 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18400 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18401 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18402 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18403 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18404 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18405 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18406 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18407 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18408 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18409 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18410 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18411 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18412 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18413 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18414 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18415 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18416 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18417 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18418 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18419 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18420 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18421 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18422 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18423 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18424 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18425 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18426 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18427 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18428 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18429 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18430 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18431 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18432 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18433 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18434 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18435 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18436 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18437 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18438 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18439 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18440 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18441 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18442 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18443 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18444 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18445 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18446 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18447 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18448 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18449 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18450 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18451 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18452 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18453 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18454 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18455 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18456 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18457 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18458 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18459 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18460 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18461 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18462 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18463 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18464 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18465 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18466 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18467 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18468 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18469 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18470 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18471 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18472 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18473 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18474 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18475 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18476 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18477 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18478 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18479 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18480 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18481 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18482 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18483 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18484 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18485 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18486 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18487 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18488 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18489 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18490 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18491 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18492 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18493 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18494 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18495 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18496 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18497 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18498 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18499 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18500 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18501 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18502 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18503 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18504 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18505 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18506 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18507 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18508 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18509 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18510 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18511 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18512 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18513 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18514 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18515 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18516 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18517 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18518 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18519 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18520 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18521 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18522 { NULL, NULL, 0, NULL }
18523 };
18524
18525
18526 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18527
18528 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18529 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18530 }
18531 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18532 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18533 }
18534 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18535 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18536 }
18537 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18538 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18539 }
18540 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18541 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18542 }
18543 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18544 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18545 }
18546 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18547 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18548 }
18549 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18550 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18551 }
18552 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18553 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18554 }
18555 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18556 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18557 }
18558 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18559 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18560 }
18561 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18562 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18563 }
18564 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18565 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18566 }
18567 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18568 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18569 }
18570 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18571 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18572 }
18573 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18574 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18575 }
18576 static void *_p_wxGridTo_p_wxPanel(void *x) {
18577 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18578 }
18579 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18580 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18581 }
18582 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18583 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18584 }
18585 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18586 return (void *)((wxPanel *) ((wxPyPanel *) x));
18587 }
18588 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18589 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18590 }
18591 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18592 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18593 }
18594 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18595 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18596 }
18597 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18598 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18599 }
18600 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18601 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18602 }
18603 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18604 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18605 }
18606 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18607 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18608 }
18609 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18610 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18611 }
18612 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18613 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18614 }
18615 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18616 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18617 }
18618 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18619 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18620 }
18621 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18622 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18623 }
18624 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18625 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18626 }
18627 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18628 return (void *)((wxWindow *) ((wxMenuBar *) x));
18629 }
18630 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18631 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18632 }
18633 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18634 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18635 }
18636 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18637 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18638 }
18639 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18640 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18641 }
18642 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18643 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18644 }
18645 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18646 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18647 }
18648 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18649 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18650 }
18651 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18652 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18653 }
18654 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18655 return (void *)((wxWindow *) ((wxPanel *) x));
18656 }
18657 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18658 return (void *)((wxWindow *) ((wxStatusBar *) x));
18659 }
18660 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18661 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18662 }
18663 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18664 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18665 }
18666 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18667 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18668 }
18669 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18670 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18671 }
18672 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18673 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18674 }
18675 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18676 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18677 }
18678 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18679 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18680 }
18681 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18682 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18683 }
18684 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18685 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18686 }
18687 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18688 return (void *)((wxWindow *) ((wxSashWindow *) x));
18689 }
18690 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18691 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18692 }
18693 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18694 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18695 }
18696 static void *_p_wxControlTo_p_wxWindow(void *x) {
18697 return (void *)((wxWindow *) ((wxControl *) x));
18698 }
18699 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18700 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18701 }
18702 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18703 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18704 }
18705 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18706 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18707 }
18708 static void *_p_wxGridTo_p_wxWindow(void *x) {
18709 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18710 }
18711 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18712 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18713 }
18714 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18715 return (void *)((wxWindow *) ((wxPyWindow *) x));
18716 }
18717 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18718 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18719 }
18720 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18721 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18722 }
18723 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18724 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18725 }
18726 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18727 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18728 }
18729 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18730 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18731 }
18732 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18733 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18734 }
18735 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18736 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18737 }
18738 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18739 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18740 }
18741 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18742 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18743 }
18744 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18745 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18746 }
18747 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18748 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18749 }
18750 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18751 return (void *)((wxControl *) ((wxControlWithItems *) x));
18752 }
18753 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18754 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18755 }
18756 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18757 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18758 }
18759 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18760 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18761 }
18762 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18763 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18764 }
18765 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18766 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18767 }
18768 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18769 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18770 }
18771 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18772 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18773 }
18774 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18775 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18776 }
18777 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18778 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18779 }
18780 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18781 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18782 }
18783 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18784 return (void *)((wxEvent *) ((wxPyEvent *) x));
18785 }
18786 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18787 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18788 }
18789 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18790 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18791 }
18792 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18793 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18794 }
18795 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18796 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18797 }
18798 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18799 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18800 }
18801 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18802 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18803 }
18804 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18805 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18806 }
18807 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18808 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18809 }
18810 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18811 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18812 }
18813 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18814 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18815 }
18816 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18817 return (void *)((wxEvent *) ((wxMoveEvent *) x));
18818 }
18819 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
18820 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
18821 }
18822 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
18823 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18824 }
18825 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
18826 return (void *)((wxEvent *) ((wxPaintEvent *) x));
18827 }
18828 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
18829 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
18830 }
18831 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
18832 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
18833 }
18834 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
18835 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
18836 }
18837 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
18838 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
18839 }
18840 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
18841 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18842 }
18843 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
18844 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
18845 }
18846 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
18847 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18848 }
18849 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
18850 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18851 }
18852 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
18853 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
18854 }
18855 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
18856 return (void *)((wxEvent *) ((wxFocusEvent *) x));
18857 }
18858 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
18859 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
18860 }
18861 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
18862 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
18863 }
18864 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
18865 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18866 }
18867 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
18868 return (void *)((wxEvent *) ((wxShowEvent *) x));
18869 }
18870 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
18871 return (void *)((wxEvent *) ((wxCommandEvent *) x));
18872 }
18873 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
18874 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
18875 }
18876 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
18877 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
18878 }
18879 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
18880 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
18881 }
18882 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
18883 return (void *)((wxEvent *) ((wxKeyEvent *) x));
18884 }
18885 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
18886 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
18887 }
18888 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
18889 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
18890 }
18891 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
18892 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
18893 }
18894 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
18895 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18896 }
18897 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
18898 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18899 }
18900 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
18901 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18902 }
18903 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
18904 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
18905 }
18906 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
18907 return (void *)((wxObject *) ((wxSizerItem *) x));
18908 }
18909 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
18910 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
18911 }
18912 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
18913 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
18914 }
18915 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
18916 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
18917 }
18918 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
18919 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
18920 }
18921 static void *_p_wxSizerTo_p_wxObject(void *x) {
18922 return (void *)((wxObject *) ((wxSizer *) x));
18923 }
18924 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
18925 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
18926 }
18927 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
18928 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
18929 }
18930 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
18931 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
18932 }
18933 static void *_p_wxEventTo_p_wxObject(void *x) {
18934 return (void *)((wxObject *) ((wxEvent *) x));
18935 }
18936 static void *_p_wxFontDataTo_p_wxObject(void *x) {
18937 return (void *)((wxObject *) ((wxFontData *) x));
18938 }
18939 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
18940 return (void *)((wxObject *) ((wxPrintData *) x));
18941 }
18942 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
18943 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
18944 }
18945 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
18946 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
18947 }
18948 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
18949 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
18950 }
18951 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
18952 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
18953 }
18954 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
18955 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
18956 }
18957 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
18958 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
18959 }
18960 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
18961 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
18962 }
18963 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
18964 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
18965 }
18966 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
18967 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
18968 }
18969 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
18970 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
18971 }
18972 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
18973 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
18974 }
18975 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
18976 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18977 }
18978 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
18979 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
18980 }
18981 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
18982 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18983 }
18984 static void *_p_wxGridEventTo_p_wxObject(void *x) {
18985 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18986 }
18987 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
18988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18989 }
18990 static void *_p_wxControlTo_p_wxObject(void *x) {
18991 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
18992 }
18993 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
18994 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
18995 }
18996 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
18997 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18998 }
18999 static void *_p_wxFSFileTo_p_wxObject(void *x) {
19000 return (void *)((wxObject *) ((wxFSFile *) x));
19001 }
19002 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
19003 return (void *)((wxObject *) ((wxFindReplaceData *) x));
19004 }
19005 static void *_p_wxGridTo_p_wxObject(void *x) {
19006 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19007 }
19008 static void *_p_wxPySizerTo_p_wxObject(void *x) {
19009 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
19010 }
19011 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
19012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19013 }
19014 static void *_p_wxColourDataTo_p_wxObject(void *x) {
19015 return (void *)((wxObject *) ((wxColourData *) x));
19016 }
19017 static void *_p_wxPyEventTo_p_wxObject(void *x) {
19018 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
19019 }
19020 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
19021 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
19022 }
19023 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
19024 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
19025 }
19026 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
19027 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19028 }
19029 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
19030 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19031 }
19032 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
19033 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19034 }
19035 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
19036 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19037 }
19038 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
19039 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19040 }
19041 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
19042 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19043 }
19044 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
19045 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19046 }
19047 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
19048 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19049 }
19050 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
19051 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19052 }
19053 static void *_p_wxShowEventTo_p_wxObject(void *x) {
19054 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
19055 }
19056 static void *_p_wxPrinterTo_p_wxObject(void *x) {
19057 return (void *)((wxObject *) ((wxPrinter *) x));
19058 }
19059 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
19060 return (void *)((wxObject *) ((wxMenuItem *) x));
19061 }
19062 static void *_p_wxDateEventTo_p_wxObject(void *x) {
19063 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
19064 }
19065 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
19066 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
19067 }
19068 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
19069 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
19070 }
19071 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
19072 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
19073 }
19074 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
19075 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
19076 }
19077 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
19078 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
19079 }
19080 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
19081 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
19082 }
19083 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
19084 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
19085 }
19086 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
19087 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
19088 }
19089 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
19090 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
19091 }
19092 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
19093 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
19094 }
19095 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
19096 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
19097 }
19098 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
19099 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
19100 }
19101 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
19102 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
19103 }
19104 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
19105 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
19106 }
19107 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
19108 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
19109 }
19110 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
19111 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
19112 }
19113 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
19114 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
19115 }
19116 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
19117 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
19118 }
19119 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
19120 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
19121 }
19122 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
19123 return (void *)((wxObject *) ((wxImageHandler *) x));
19124 }
19125 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
19126 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
19127 }
19128 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
19129 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
19130 }
19131 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
19132 return (void *)((wxObject *) ((wxEvtHandler *) x));
19133 }
19134 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
19135 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
19136 }
19137 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
19138 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19139 }
19140 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
19141 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19142 }
19143 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
19144 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19145 }
19146 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
19147 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
19148 }
19149 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
19150 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
19151 }
19152 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
19153 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19154 }
19155 static void *_p_wxImageTo_p_wxObject(void *x) {
19156 return (void *)((wxObject *) ((wxImage *) x));
19157 }
19158 static void *_p_wxFrameTo_p_wxObject(void *x) {
19159 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19160 }
19161 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
19162 return (void *)((wxObject *) ((wxPyPrintout *) x));
19163 }
19164 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19165 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19166 }
19167 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19168 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19169 }
19170 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19171 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19172 }
19173 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19174 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19175 }
19176 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19177 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19178 }
19179 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19180 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19181 }
19182 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19183 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19184 }
19185 static void *_p_wxWindowTo_p_wxObject(void *x) {
19186 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19187 }
19188 static void *_p_wxMenuTo_p_wxObject(void *x) {
19189 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19190 }
19191 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19192 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19193 }
19194 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19195 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19196 }
19197 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19198 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19199 }
19200 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19201 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19202 }
19203 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19204 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19205 }
19206 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19207 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19208 }
19209 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19210 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19211 }
19212 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19213 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19214 }
19215 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19216 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19217 }
19218 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19219 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19220 }
19221 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19222 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19223 }
19224 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19225 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19226 }
19227 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19228 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19229 }
19230 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19231 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19232 }
19233 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19234 return (void *)((wxObject *) ((wxPrintPreview *) x));
19235 }
19236 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19237 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19238 }
19239 static void *_p_wxPanelTo_p_wxObject(void *x) {
19240 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19241 }
19242 static void *_p_wxDialogTo_p_wxObject(void *x) {
19243 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19244 }
19245 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19246 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19247 }
19248 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19249 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19250 }
19251 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19252 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19253 }
19254 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19255 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19256 }
19257 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19258 return (void *)((wxObject *) ((wxPrintDialog *) x));
19259 }
19260 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19261 return (void *)((wxObject *) ((wxFileSystem *) x));
19262 }
19263 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19264 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19265 }
19266 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19267 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19268 }
19269 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19270 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19271 }
19272 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19273 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19274 }
19275 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19276 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19277 }
19278 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19279 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19280 }
19281 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19282 return (void *)((wxObject *) ((wxGridTableBase *) x));
19283 }
19284 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19285 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19286 }
19287 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19288 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19289 }
19290 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19291 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19292 }
19293 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19294 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19295 }
19296 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19297 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19298 }
19299 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19300 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19301 }
19302 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19303 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19304 }
19305 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19306 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19307 }
19308 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19309 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19310 }
19311 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19312 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19313 }
19314 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19315 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19316 }
19317 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19318 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19319 }
19320 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19321 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19322 }
19323 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19324 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19325 }
19326 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19327 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19328 }
19329 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19330 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19331 }
19332 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19333 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19334 }
19335 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19336 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19337 }
19338 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19339 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19340 }
19341 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19342 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19343 }
19344 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19345 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19346 }
19347 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19348 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19349 }
19350 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19351 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19352 }
19353 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19354 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19355 }
19356 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19357 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19358 }
19359 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19360 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19361 }
19362 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19363 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19364 }
19365 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19366 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19367 }
19368 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19369 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19370 }
19371 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19372 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19373 }
19374 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19375 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19376 }
19377 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19378 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19379 }
19380 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19381 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19382 }
19383 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19384 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19385 }
19386 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19387 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19388 }
19389 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19390 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19391 }
19392 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19393 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19394 }
19395 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19396 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19397 }
19398 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19399 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19400 }
19401 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19402 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19403 }
19404 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19405 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19406 }
19407 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19408 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19409 }
19410 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19411 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19412 }
19413 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19414 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19415 }
19416 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19417 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19418 }
19419 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19420 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19421 }
19422 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19423 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19424 }
19425 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19426 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19427 }
19428 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19429 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19430 }
19431 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19432 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19433 }
19434 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19435 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19436 }
19437 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19438 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19439 }
19440 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19441 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19442 }
19443 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19444 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19445 }
19446 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19447 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19448 }
19449 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19450 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19451 }
19452 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19453 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19454 }
19455 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19456 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19457 }
19458 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19459 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19460 }
19461 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19462 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19463 }
19464 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19465 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19466 }
19467 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19468 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19469 }
19470 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19471 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19472 }
19473 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19474 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19475 }
19476 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19477 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19478 }
19479 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19480 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19481 }
19482 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19483 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19484 }
19485 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19486 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19487 }
19488 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19489 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19490 }
19491 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19492 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19493 }
19494 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19495 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19496 }
19497 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19498 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19499 }
19500 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19501 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19502 }
19503 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19504 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19505 }
19506 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19507 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19508 }
19509 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19510 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19511 }
19512 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19513 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19514 }
19515 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19516 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19517 }
19518 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19519 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19520 }
19521 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19522 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19523 }
19524 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19525 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19526 }
19527 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19528 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19529 }
19530 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19531 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19532 }
19533 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19534 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19535 }
19536 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
19537 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
19538 }
19539 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19540 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19541 }
19542 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19543 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19544 }
19545 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19546 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19547 }
19548 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19549 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19550 }
19551 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19552 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19553 }
19554 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19555 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19556 }
19557 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19558 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19559 }
19560 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19561 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19562 }
19563 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19564 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19565 }
19566 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
19567 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
19568 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
19569 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
19570 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
19571 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
19572 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
19573 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
19574 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
19575 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
19576 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0};
19577 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
19578 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0};
19579 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
19580 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
19581 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
19582 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
19583 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
19584 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
19585 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0};
19586 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
19587 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
19588 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
19589 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
19590 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
19591 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
19592 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
19593 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
19594 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
19595 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
19596 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
19597 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
19598 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
19599 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0};
19600 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
19601 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
19602 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
19603 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
19604 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
19605 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
19606 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
19607 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
19608 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
19609 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
19610 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
19611 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
19612 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
19613 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
19614 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
19615 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0};
19616 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
19617 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
19618 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
19619 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0};
19620 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
19621 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0};
19622 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0};
19623 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0};
19624 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
19625 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
19626 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
19627 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0};
19628 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0};
19629 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0};
19630 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0};
19631 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0};
19632 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0};
19633 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0};
19634 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0};
19635 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0};
19636 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0};
19637 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0};
19638 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0};
19639 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0};
19640 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0};
19641 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0};
19642 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0};
19643 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0};
19644 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0};
19645 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0};
19646 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0};
19647 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0};
19648 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0};
19649 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0};
19650 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
19651 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0};
19652 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0};
19653 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0};
19654 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0};
19655 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0};
19656 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0};
19657 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0};
19658 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0};
19659 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0};
19660 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0};
19661 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0};
19662 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0};
19663 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0};
19664 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0};
19665 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
19666 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, 0};
19667 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, 0};
19668 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, 0};
19669 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, 0};
19670 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, 0};
19671 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, 0};
19672 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, 0};
19673 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, 0};
19674 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, 0};
19675 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, 0};
19676 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, 0};
19677 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, 0};
19678 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, 0};
19679 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, 0};
19680 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, 0};
19681 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, 0};
19682 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, 0};
19683 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, 0};
19684 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, 0};
19685 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, 0};
19686 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, 0};
19687 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, 0};
19688 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, 0};
19689 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, 0};
19690 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, 0};
19691 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, 0};
19692 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, 0};
19693 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
19694 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
19695 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
19696 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
19697 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
19698 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
19699 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
19700 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
19701 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
19702 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
19703 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
19704 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0};
19705 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0};
19706 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
19707 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
19708 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0};
19709 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
19710 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0};
19711 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
19712 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0};
19713 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0};
19714 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
19715 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
19716 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
19717 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
19718 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
19719 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
19720 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
19721 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
19722 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
19723 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
19724 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
19725 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
19726 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
19727 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
19728 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
19729 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
19730 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
19731 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0};
19732 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0};
19733 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0};
19734 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0};
19735 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0};
19736 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
19737 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0};
19738 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0};
19739 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, 0};
19740 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
19741 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
19742 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, 0};
19743 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, 0};
19744 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, 0};
19745 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, 0};
19746 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
19747 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, 0};
19748 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
19749 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
19750 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
19751 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
19752 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
19753 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
19754 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
19755
19756 static swig_type_info *swig_type_initial[] = {
19757 &_swigt__p_char,
19758 &_swigt__p_form_ops_t,
19759 &_swigt__p_int,
19760 &_swigt__p_long,
19761 &_swigt__p_unsigned_char,
19762 &_swigt__p_unsigned_int,
19763 &_swigt__p_unsigned_long,
19764 &_swigt__p_wxANIHandler,
19765 &_swigt__p_wxAcceleratorTable,
19766 &_swigt__p_wxActivateEvent,
19767 &_swigt__p_wxArrayString,
19768 &_swigt__p_wxBMPHandler,
19769 &_swigt__p_wxBoxSizer,
19770 &_swigt__p_wxCURHandler,
19771 &_swigt__p_wxCalculateLayoutEvent,
19772 &_swigt__p_wxChildFocusEvent,
19773 &_swigt__p_wxCloseEvent,
19774 &_swigt__p_wxColour,
19775 &_swigt__p_wxColourData,
19776 &_swigt__p_wxColourDialog,
19777 &_swigt__p_wxCommandEvent,
19778 &_swigt__p_wxContextMenuEvent,
19779 &_swigt__p_wxControl,
19780 &_swigt__p_wxControlWithItems,
19781 &_swigt__p_wxDC,
19782 &_swigt__p_wxDateEvent,
19783 &_swigt__p_wxDialog,
19784 &_swigt__p_wxDirDialog,
19785 &_swigt__p_wxDisplayChangedEvent,
19786 &_swigt__p_wxDropFilesEvent,
19787 &_swigt__p_wxDuplexMode,
19788 &_swigt__p_wxEraseEvent,
19789 &_swigt__p_wxEvent,
19790 &_swigt__p_wxEvtHandler,
19791 &_swigt__p_wxFSFile,
19792 &_swigt__p_wxFileDialog,
19793 &_swigt__p_wxFileSystem,
19794 &_swigt__p_wxFindDialogEvent,
19795 &_swigt__p_wxFindReplaceData,
19796 &_swigt__p_wxFindReplaceDialog,
19797 &_swigt__p_wxFlexGridSizer,
19798 &_swigt__p_wxFocusEvent,
19799 &_swigt__p_wxFont,
19800 &_swigt__p_wxFontData,
19801 &_swigt__p_wxFontDialog,
19802 &_swigt__p_wxFrame,
19803 &_swigt__p_wxGBSizerItem,
19804 &_swigt__p_wxGIFHandler,
19805 &_swigt__p_wxGrid,
19806 &_swigt__p_wxGridBagSizer,
19807 &_swigt__p_wxGridCellAttr,
19808 &_swigt__p_wxGridCellAttrProvider,
19809 &_swigt__p_wxGridCellAutoWrapStringEditor,
19810 &_swigt__p_wxGridCellAutoWrapStringRenderer,
19811 &_swigt__p_wxGridCellBoolEditor,
19812 &_swigt__p_wxGridCellBoolRenderer,
19813 &_swigt__p_wxGridCellChoiceEditor,
19814 &_swigt__p_wxGridCellCoords,
19815 &_swigt__p_wxGridCellDateTimeRenderer,
19816 &_swigt__p_wxGridCellEditor,
19817 &_swigt__p_wxGridCellEnumEditor,
19818 &_swigt__p_wxGridCellEnumRenderer,
19819 &_swigt__p_wxGridCellFloatEditor,
19820 &_swigt__p_wxGridCellFloatRenderer,
19821 &_swigt__p_wxGridCellNumberEditor,
19822 &_swigt__p_wxGridCellNumberRenderer,
19823 &_swigt__p_wxGridCellRenderer,
19824 &_swigt__p_wxGridCellStringRenderer,
19825 &_swigt__p_wxGridCellTextEditor,
19826 &_swigt__p_wxGridEditorCreatedEvent,
19827 &_swigt__p_wxGridEvent,
19828 &_swigt__p_wxGridRangeSelectEvent,
19829 &_swigt__p_wxGridSizeEvent,
19830 &_swigt__p_wxGridSizer,
19831 &_swigt__p_wxGridStringTable,
19832 &_swigt__p_wxGridTableBase,
19833 &_swigt__p_wxGridTableMessage,
19834 &_swigt__p_wxICOHandler,
19835 &_swigt__p_wxIconizeEvent,
19836 &_swigt__p_wxIdleEvent,
19837 &_swigt__p_wxImage,
19838 &_swigt__p_wxImageHandler,
19839 &_swigt__p_wxIndividualLayoutConstraint,
19840 &_swigt__p_wxInitDialogEvent,
19841 &_swigt__p_wxJPEGHandler,
19842 &_swigt__p_wxKeyEvent,
19843 &_swigt__p_wxLayoutAlgorithm,
19844 &_swigt__p_wxLayoutConstraints,
19845 &_swigt__p_wxMDIChildFrame,
19846 &_swigt__p_wxMDIClientWindow,
19847 &_swigt__p_wxMDIParentFrame,
19848 &_swigt__p_wxMaximizeEvent,
19849 &_swigt__p_wxMenu,
19850 &_swigt__p_wxMenuBar,
19851 &_swigt__p_wxMenuEvent,
19852 &_swigt__p_wxMenuItem,
19853 &_swigt__p_wxMessageDialog,
19854 &_swigt__p_wxMiniFrame,
19855 &_swigt__p_wxMouseCaptureChangedEvent,
19856 &_swigt__p_wxMouseEvent,
19857 &_swigt__p_wxMoveEvent,
19858 &_swigt__p_wxMultiChoiceDialog,
19859 &_swigt__p_wxNavigationKeyEvent,
19860 &_swigt__p_wxNcPaintEvent,
19861 &_swigt__p_wxNotifyEvent,
19862 &_swigt__p_wxObject,
19863 &_swigt__p_wxPCXHandler,
19864 &_swigt__p_wxPNGHandler,
19865 &_swigt__p_wxPNMHandler,
19866 &_swigt__p_wxPageSetupDialog,
19867 &_swigt__p_wxPageSetupDialogData,
19868 &_swigt__p_wxPaintEvent,
19869 &_swigt__p_wxPaletteChangedEvent,
19870 &_swigt__p_wxPanel,
19871 &_swigt__p_wxPaperSize,
19872 &_swigt__p_wxPasswordEntryDialog,
19873 &_swigt__p_wxPoint,
19874 &_swigt__p_wxPopupWindow,
19875 &_swigt__p_wxPreviewCanvas,
19876 &_swigt__p_wxPreviewControlBar,
19877 &_swigt__p_wxPreviewFrame,
19878 &_swigt__p_wxPrintData,
19879 &_swigt__p_wxPrintDialog,
19880 &_swigt__p_wxPrintDialogData,
19881 &_swigt__p_wxPrintPreview,
19882 &_swigt__p_wxPrinter,
19883 &_swigt__p_wxProgressDialog,
19884 &_swigt__p_wxPyApp,
19885 &_swigt__p_wxPyCommandEvent,
19886 &_swigt__p_wxPyEvent,
19887 &_swigt__p_wxPyGridCellAttrProvider,
19888 &_swigt__p_wxPyGridCellEditor,
19889 &_swigt__p_wxPyGridCellRenderer,
19890 &_swigt__p_wxPyGridTableBase,
19891 &_swigt__p_wxPyHtmlListBox,
19892 &_swigt__p_wxPyImageHandler,
19893 &_swigt__p_wxPyPanel,
19894 &_swigt__p_wxPyPopupTransientWindow,
19895 &_swigt__p_wxPyPreviewControlBar,
19896 &_swigt__p_wxPyPreviewFrame,
19897 &_swigt__p_wxPyPrintPreview,
19898 &_swigt__p_wxPyPrintout,
19899 &_swigt__p_wxPyScrolledWindow,
19900 &_swigt__p_wxPySizer,
19901 &_swigt__p_wxPyTaskBarIcon,
19902 &_swigt__p_wxPyVListBox,
19903 &_swigt__p_wxPyVScrolledWindow,
19904 &_swigt__p_wxPyValidator,
19905 &_swigt__p_wxPyWindow,
19906 &_swigt__p_wxQueryLayoutInfoEvent,
19907 &_swigt__p_wxQueryNewPaletteEvent,
19908 &_swigt__p_wxRect,
19909 &_swigt__p_wxSashEvent,
19910 &_swigt__p_wxSashLayoutWindow,
19911 &_swigt__p_wxSashWindow,
19912 &_swigt__p_wxScrollEvent,
19913 &_swigt__p_wxScrollWinEvent,
19914 &_swigt__p_wxScrolledWindow,
19915 &_swigt__p_wxSetCursorEvent,
19916 &_swigt__p_wxShowEvent,
19917 &_swigt__p_wxSingleChoiceDialog,
19918 &_swigt__p_wxSize,
19919 &_swigt__p_wxSizeEvent,
19920 &_swigt__p_wxSizer,
19921 &_swigt__p_wxSizerItem,
19922 &_swigt__p_wxSplashScreen,
19923 &_swigt__p_wxSplashScreenWindow,
19924 &_swigt__p_wxSplitterEvent,
19925 &_swigt__p_wxSplitterWindow,
19926 &_swigt__p_wxStaticBoxSizer,
19927 &_swigt__p_wxStatusBar,
19928 &_swigt__p_wxStdDialogButtonSizer,
19929 &_swigt__p_wxString,
19930 &_swigt__p_wxSysColourChangedEvent,
19931 &_swigt__p_wxTIFFHandler,
19932 &_swigt__p_wxTaskBarIconEvent,
19933 &_swigt__p_wxTextEntryDialog,
19934 &_swigt__p_wxTipWindow,
19935 &_swigt__p_wxTopLevelWindow,
19936 &_swigt__p_wxUpdateUIEvent,
19937 &_swigt__p_wxValidator,
19938 &_swigt__p_wxVisualAttributes,
19939 &_swigt__p_wxWindow,
19940 &_swigt__p_wxWindowCreateEvent,
19941 &_swigt__p_wxWindowDestroyEvent,
19942 &_swigt__p_wxXPMHandler,
19943 &_swigt__ptrdiff_t,
19944 &_swigt__std__ptrdiff_t,
19945 &_swigt__unsigned_int,
19946 };
19947
19948 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
19949 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
19950 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
19951 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
19952 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
19953 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
19954 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
19955 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
19956 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
19957 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
19958 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
19959 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
19960 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
19961 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
19962 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
19963 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
19964 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
19965 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
19966 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
19967 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
19968 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}};
19969 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
19970 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}};
19971 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
19972 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
19973 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
19974 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
19975 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
19976 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
19977 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
19978 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
19979 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
19980 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
19981 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
19982 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
19983 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
19984 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
19985 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
19986 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
19987 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
19988 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
19989 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
19990 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
19991 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
19992 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
19993 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
19994 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
19995 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
19996 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
19997 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
19998 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
19999 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
20000 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
20001 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}};
20002 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
20003 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
20004 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
20005 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
20006 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
20007 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
20008 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
20009 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
20010 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
20011 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
20012 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
20013 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
20014 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
20015 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
20016 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
20017 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
20018 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
20019 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
20020 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
20021 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
20022 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
20023 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
20024 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
20025 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
20026 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
20027 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
20028 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
20029 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
20030 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
20031 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
20032 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
20033 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
20034 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
20035 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
20036 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
20037 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
20038 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
20039 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
20040 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
20041 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
20042 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
20043 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
20044 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
20045 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
20046 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}};
20047 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
20048 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
20049 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
20050 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}};
20051 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
20052 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
20053 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
20054 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
20055 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}};
20056 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
20057 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
20058 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}};
20059 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
20060 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
20061 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
20062 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
20063 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
20064 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
20065 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}};
20066 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}};
20067 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}};
20068 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
20069 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
20070 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
20071 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
20072 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
20073 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}};
20074 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
20075 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
20076 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}};
20077 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
20078 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
20079 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
20080 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
20081 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
20082 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
20083 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
20084 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
20085 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
20086 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
20087 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
20088 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
20089 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
20090 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
20091 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
20092 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
20093 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
20094 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
20095 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
20096 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
20097 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
20098 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
20099 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
20100 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
20101 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
20102 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
20103 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
20104 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
20105 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
20106 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
20107 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
20108 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
20109 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
20110 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
20111 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
20112 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
20113 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
20114 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
20115 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
20116 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
20117 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
20118 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
20119 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
20120 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}};
20121 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}};
20122 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
20123 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
20124 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
20125 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
20126 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
20127 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
20128 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
20129 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}};
20130 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
20131 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
20132 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
20133 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}};
20134 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
20135 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
20136 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20137
20138 static swig_cast_info *swig_cast_initial[] = {
20139 _swigc__p_char,
20140 _swigc__p_form_ops_t,
20141 _swigc__p_int,
20142 _swigc__p_long,
20143 _swigc__p_unsigned_char,
20144 _swigc__p_unsigned_int,
20145 _swigc__p_unsigned_long,
20146 _swigc__p_wxANIHandler,
20147 _swigc__p_wxAcceleratorTable,
20148 _swigc__p_wxActivateEvent,
20149 _swigc__p_wxArrayString,
20150 _swigc__p_wxBMPHandler,
20151 _swigc__p_wxBoxSizer,
20152 _swigc__p_wxCURHandler,
20153 _swigc__p_wxCalculateLayoutEvent,
20154 _swigc__p_wxChildFocusEvent,
20155 _swigc__p_wxCloseEvent,
20156 _swigc__p_wxColour,
20157 _swigc__p_wxColourData,
20158 _swigc__p_wxColourDialog,
20159 _swigc__p_wxCommandEvent,
20160 _swigc__p_wxContextMenuEvent,
20161 _swigc__p_wxControl,
20162 _swigc__p_wxControlWithItems,
20163 _swigc__p_wxDC,
20164 _swigc__p_wxDateEvent,
20165 _swigc__p_wxDialog,
20166 _swigc__p_wxDirDialog,
20167 _swigc__p_wxDisplayChangedEvent,
20168 _swigc__p_wxDropFilesEvent,
20169 _swigc__p_wxDuplexMode,
20170 _swigc__p_wxEraseEvent,
20171 _swigc__p_wxEvent,
20172 _swigc__p_wxEvtHandler,
20173 _swigc__p_wxFSFile,
20174 _swigc__p_wxFileDialog,
20175 _swigc__p_wxFileSystem,
20176 _swigc__p_wxFindDialogEvent,
20177 _swigc__p_wxFindReplaceData,
20178 _swigc__p_wxFindReplaceDialog,
20179 _swigc__p_wxFlexGridSizer,
20180 _swigc__p_wxFocusEvent,
20181 _swigc__p_wxFont,
20182 _swigc__p_wxFontData,
20183 _swigc__p_wxFontDialog,
20184 _swigc__p_wxFrame,
20185 _swigc__p_wxGBSizerItem,
20186 _swigc__p_wxGIFHandler,
20187 _swigc__p_wxGrid,
20188 _swigc__p_wxGridBagSizer,
20189 _swigc__p_wxGridCellAttr,
20190 _swigc__p_wxGridCellAttrProvider,
20191 _swigc__p_wxGridCellAutoWrapStringEditor,
20192 _swigc__p_wxGridCellAutoWrapStringRenderer,
20193 _swigc__p_wxGridCellBoolEditor,
20194 _swigc__p_wxGridCellBoolRenderer,
20195 _swigc__p_wxGridCellChoiceEditor,
20196 _swigc__p_wxGridCellCoords,
20197 _swigc__p_wxGridCellDateTimeRenderer,
20198 _swigc__p_wxGridCellEditor,
20199 _swigc__p_wxGridCellEnumEditor,
20200 _swigc__p_wxGridCellEnumRenderer,
20201 _swigc__p_wxGridCellFloatEditor,
20202 _swigc__p_wxGridCellFloatRenderer,
20203 _swigc__p_wxGridCellNumberEditor,
20204 _swigc__p_wxGridCellNumberRenderer,
20205 _swigc__p_wxGridCellRenderer,
20206 _swigc__p_wxGridCellStringRenderer,
20207 _swigc__p_wxGridCellTextEditor,
20208 _swigc__p_wxGridEditorCreatedEvent,
20209 _swigc__p_wxGridEvent,
20210 _swigc__p_wxGridRangeSelectEvent,
20211 _swigc__p_wxGridSizeEvent,
20212 _swigc__p_wxGridSizer,
20213 _swigc__p_wxGridStringTable,
20214 _swigc__p_wxGridTableBase,
20215 _swigc__p_wxGridTableMessage,
20216 _swigc__p_wxICOHandler,
20217 _swigc__p_wxIconizeEvent,
20218 _swigc__p_wxIdleEvent,
20219 _swigc__p_wxImage,
20220 _swigc__p_wxImageHandler,
20221 _swigc__p_wxIndividualLayoutConstraint,
20222 _swigc__p_wxInitDialogEvent,
20223 _swigc__p_wxJPEGHandler,
20224 _swigc__p_wxKeyEvent,
20225 _swigc__p_wxLayoutAlgorithm,
20226 _swigc__p_wxLayoutConstraints,
20227 _swigc__p_wxMDIChildFrame,
20228 _swigc__p_wxMDIClientWindow,
20229 _swigc__p_wxMDIParentFrame,
20230 _swigc__p_wxMaximizeEvent,
20231 _swigc__p_wxMenu,
20232 _swigc__p_wxMenuBar,
20233 _swigc__p_wxMenuEvent,
20234 _swigc__p_wxMenuItem,
20235 _swigc__p_wxMessageDialog,
20236 _swigc__p_wxMiniFrame,
20237 _swigc__p_wxMouseCaptureChangedEvent,
20238 _swigc__p_wxMouseEvent,
20239 _swigc__p_wxMoveEvent,
20240 _swigc__p_wxMultiChoiceDialog,
20241 _swigc__p_wxNavigationKeyEvent,
20242 _swigc__p_wxNcPaintEvent,
20243 _swigc__p_wxNotifyEvent,
20244 _swigc__p_wxObject,
20245 _swigc__p_wxPCXHandler,
20246 _swigc__p_wxPNGHandler,
20247 _swigc__p_wxPNMHandler,
20248 _swigc__p_wxPageSetupDialog,
20249 _swigc__p_wxPageSetupDialogData,
20250 _swigc__p_wxPaintEvent,
20251 _swigc__p_wxPaletteChangedEvent,
20252 _swigc__p_wxPanel,
20253 _swigc__p_wxPaperSize,
20254 _swigc__p_wxPasswordEntryDialog,
20255 _swigc__p_wxPoint,
20256 _swigc__p_wxPopupWindow,
20257 _swigc__p_wxPreviewCanvas,
20258 _swigc__p_wxPreviewControlBar,
20259 _swigc__p_wxPreviewFrame,
20260 _swigc__p_wxPrintData,
20261 _swigc__p_wxPrintDialog,
20262 _swigc__p_wxPrintDialogData,
20263 _swigc__p_wxPrintPreview,
20264 _swigc__p_wxPrinter,
20265 _swigc__p_wxProgressDialog,
20266 _swigc__p_wxPyApp,
20267 _swigc__p_wxPyCommandEvent,
20268 _swigc__p_wxPyEvent,
20269 _swigc__p_wxPyGridCellAttrProvider,
20270 _swigc__p_wxPyGridCellEditor,
20271 _swigc__p_wxPyGridCellRenderer,
20272 _swigc__p_wxPyGridTableBase,
20273 _swigc__p_wxPyHtmlListBox,
20274 _swigc__p_wxPyImageHandler,
20275 _swigc__p_wxPyPanel,
20276 _swigc__p_wxPyPopupTransientWindow,
20277 _swigc__p_wxPyPreviewControlBar,
20278 _swigc__p_wxPyPreviewFrame,
20279 _swigc__p_wxPyPrintPreview,
20280 _swigc__p_wxPyPrintout,
20281 _swigc__p_wxPyScrolledWindow,
20282 _swigc__p_wxPySizer,
20283 _swigc__p_wxPyTaskBarIcon,
20284 _swigc__p_wxPyVListBox,
20285 _swigc__p_wxPyVScrolledWindow,
20286 _swigc__p_wxPyValidator,
20287 _swigc__p_wxPyWindow,
20288 _swigc__p_wxQueryLayoutInfoEvent,
20289 _swigc__p_wxQueryNewPaletteEvent,
20290 _swigc__p_wxRect,
20291 _swigc__p_wxSashEvent,
20292 _swigc__p_wxSashLayoutWindow,
20293 _swigc__p_wxSashWindow,
20294 _swigc__p_wxScrollEvent,
20295 _swigc__p_wxScrollWinEvent,
20296 _swigc__p_wxScrolledWindow,
20297 _swigc__p_wxSetCursorEvent,
20298 _swigc__p_wxShowEvent,
20299 _swigc__p_wxSingleChoiceDialog,
20300 _swigc__p_wxSize,
20301 _swigc__p_wxSizeEvent,
20302 _swigc__p_wxSizer,
20303 _swigc__p_wxSizerItem,
20304 _swigc__p_wxSplashScreen,
20305 _swigc__p_wxSplashScreenWindow,
20306 _swigc__p_wxSplitterEvent,
20307 _swigc__p_wxSplitterWindow,
20308 _swigc__p_wxStaticBoxSizer,
20309 _swigc__p_wxStatusBar,
20310 _swigc__p_wxStdDialogButtonSizer,
20311 _swigc__p_wxString,
20312 _swigc__p_wxSysColourChangedEvent,
20313 _swigc__p_wxTIFFHandler,
20314 _swigc__p_wxTaskBarIconEvent,
20315 _swigc__p_wxTextEntryDialog,
20316 _swigc__p_wxTipWindow,
20317 _swigc__p_wxTopLevelWindow,
20318 _swigc__p_wxUpdateUIEvent,
20319 _swigc__p_wxValidator,
20320 _swigc__p_wxVisualAttributes,
20321 _swigc__p_wxWindow,
20322 _swigc__p_wxWindowCreateEvent,
20323 _swigc__p_wxWindowDestroyEvent,
20324 _swigc__p_wxXPMHandler,
20325 _swigc__ptrdiff_t,
20326 _swigc__std__ptrdiff_t,
20327 _swigc__unsigned_int,
20328 };
20329
20330
20331 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20332
20333 static swig_const_info swig_const_table[] = {
20334 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
20335 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
20336 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
20337 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
20338 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
20339 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
20340 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
20341 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
20342 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
20343 {0, 0, 0, 0.0, 0, 0}};
20344
20345 #ifdef __cplusplus
20346 }
20347 #endif
20348 /*************************************************************************
20349 * Type initialization:
20350 * This problem is tough by the requirement that no dynamic
20351 * memory is used. Also, since swig_type_info structures store pointers to
20352 * swig_cast_info structures and swig_cast_info structures store pointers back
20353 * to swig_type_info structures, we need some lookup code at initialization.
20354 * The idea is that swig generates all the structures that are needed.
20355 * The runtime then collects these partially filled structures.
20356 * The SWIG_InitializeModule function takes these initial arrays out of
20357 * swig_module, and does all the lookup, filling in the swig_module.types
20358 * array with the correct data and linking the correct swig_cast_info
20359 * structures together.
20360
20361 * The generated swig_type_info structures are assigned staticly to an initial
20362 * array. We just loop though that array, and handle each type individually.
20363 * First we lookup if this type has been already loaded, and if so, use the
20364 * loaded structure instead of the generated one. Then we have to fill in the
20365 * cast linked list. The cast data is initially stored in something like a
20366 * two-dimensional array. Each row corresponds to a type (there are the same
20367 * number of rows as there are in the swig_type_initial array). Each entry in
20368 * a column is one of the swig_cast_info structures for that type.
20369 * The cast_initial array is actually an array of arrays, because each row has
20370 * a variable number of columns. So to actually build the cast linked list,
20371 * we find the array of casts associated with the type, and loop through it
20372 * adding the casts to the list. The one last trick we need to do is making
20373 * sure the type pointer in the swig_cast_info struct is correct.
20374
20375 * First off, we lookup the cast->type name to see if it is already loaded.
20376 * There are three cases to handle:
20377 * 1) If the cast->type has already been loaded AND the type we are adding
20378 * casting info to has not been loaded (it is in this module), THEN we
20379 * replace the cast->type pointer with the type pointer that has already
20380 * been loaded.
20381 * 2) If BOTH types (the one we are adding casting info to, and the
20382 * cast->type) are loaded, THEN the cast info has already been loaded by
20383 * the previous module so we just ignore it.
20384 * 3) Finally, if cast->type has not already been loaded, then we add that
20385 * swig_cast_info to the linked list (because the cast->type) pointer will
20386 * be correct.
20387 **/
20388
20389 #ifdef __cplusplus
20390 extern "C" {
20391 #if 0
20392 } /* c-mode */
20393 #endif
20394 #endif
20395
20396 #if 0
20397 #define SWIGRUNTIME_DEBUG
20398 #endif
20399
20400 SWIGRUNTIME void
20401 SWIG_InitializeModule(void *clientdata) {
20402 size_t i;
20403 swig_module_info *module_head;
20404 static int init_run = 0;
20405
20406 clientdata = clientdata;
20407
20408 if (init_run) return;
20409 init_run = 1;
20410
20411 /* Initialize the swig_module */
20412 swig_module.type_initial = swig_type_initial;
20413 swig_module.cast_initial = swig_cast_initial;
20414
20415 /* Try and load any already created modules */
20416 module_head = SWIG_GetModule(clientdata);
20417 if (module_head) {
20418 swig_module.next = module_head->next;
20419 module_head->next = &swig_module;
20420 } else {
20421 /* This is the first module loaded */
20422 swig_module.next = &swig_module;
20423 SWIG_SetModule(clientdata, &swig_module);
20424 }
20425
20426 /* Now work on filling in swig_module.types */
20427 #ifdef SWIGRUNTIME_DEBUG
20428 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20429 #endif
20430 for (i = 0; i < swig_module.size; ++i) {
20431 swig_type_info *type = 0;
20432 swig_type_info *ret;
20433 swig_cast_info *cast;
20434
20435 #ifdef SWIGRUNTIME_DEBUG
20436 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20437 #endif
20438
20439 /* if there is another module already loaded */
20440 if (swig_module.next != &swig_module) {
20441 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20442 }
20443 if (type) {
20444 /* Overwrite clientdata field */
20445 #ifdef SWIGRUNTIME_DEBUG
20446 printf("SWIG_InitializeModule: found type %s\n", type->name);
20447 #endif
20448 if (swig_module.type_initial[i]->clientdata) {
20449 type->clientdata = swig_module.type_initial[i]->clientdata;
20450 #ifdef SWIGRUNTIME_DEBUG
20451 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20452 #endif
20453 }
20454 } else {
20455 type = swig_module.type_initial[i];
20456 }
20457
20458 /* Insert casting types */
20459 cast = swig_module.cast_initial[i];
20460 while (cast->type) {
20461 /* Don't need to add information already in the list */
20462 ret = 0;
20463 #ifdef SWIGRUNTIME_DEBUG
20464 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20465 #endif
20466 if (swig_module.next != &swig_module) {
20467 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20468 #ifdef SWIGRUNTIME_DEBUG
20469 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20470 #endif
20471 }
20472 if (ret) {
20473 if (type == swig_module.type_initial[i]) {
20474 #ifdef SWIGRUNTIME_DEBUG
20475 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20476 #endif
20477 cast->type = ret;
20478 ret = 0;
20479 } else {
20480 /* Check for casting already in the list */
20481 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20482 #ifdef SWIGRUNTIME_DEBUG
20483 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20484 #endif
20485 if (!ocast) ret = 0;
20486 }
20487 }
20488
20489 if (!ret) {
20490 #ifdef SWIGRUNTIME_DEBUG
20491 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20492 #endif
20493 if (type->cast) {
20494 type->cast->prev = cast;
20495 cast->next = type->cast;
20496 }
20497 type->cast = cast;
20498 }
20499 cast++;
20500 }
20501 /* Set entry in modules->types array equal to the type */
20502 swig_module.types[i] = type;
20503 }
20504 swig_module.types[i] = 0;
20505
20506 #ifdef SWIGRUNTIME_DEBUG
20507 printf("**** SWIG_InitializeModule: Cast List ******\n");
20508 for (i = 0; i < swig_module.size; ++i) {
20509 int j = 0;
20510 swig_cast_info *cast = swig_module.cast_initial[i];
20511 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20512 while (cast->type) {
20513 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
20514 cast++;
20515 ++j;
20516 }
20517 printf("---- Total casts: %d\n",j);
20518 }
20519 printf("**** SWIG_InitializeModule: Cast List ******\n");
20520 #endif
20521 }
20522
20523 /* This function will propagate the clientdata field of type to
20524 * any new swig_type_info structures that have been added into the list
20525 * of equivalent types. It is like calling
20526 * SWIG_TypeClientData(type, clientdata) a second time.
20527 */
20528 SWIGRUNTIME void
20529 SWIG_PropagateClientData(void) {
20530 size_t i;
20531 swig_cast_info *equiv;
20532 static int init_run = 0;
20533
20534 if (init_run) return;
20535 init_run = 1;
20536
20537 for (i = 0; i < swig_module.size; i++) {
20538 if (swig_module.types[i]->clientdata) {
20539 equiv = swig_module.types[i]->cast;
20540 while (equiv) {
20541 if (!equiv->converter) {
20542 if (equiv->type && !equiv->type->clientdata)
20543 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
20544 }
20545 equiv = equiv->next;
20546 }
20547 }
20548 }
20549 }
20550
20551 #ifdef __cplusplus
20552 #if 0
20553 {
20554 /* c-mode */
20555 #endif
20556 }
20557 #endif
20558
20559
20560
20561 #ifdef __cplusplus
20562 extern "C" {
20563 #endif
20564
20565 /* Python-specific SWIG API */
20566 #define SWIG_newvarlink() SWIG_Python_newvarlink()
20567 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
20568 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
20569
20570 /* -----------------------------------------------------------------------------
20571 * global variable support code.
20572 * ----------------------------------------------------------------------------- */
20573
20574 typedef struct swig_globalvar {
20575 char *name; /* Name of global variable */
20576 PyObject *(*get_attr)(void); /* Return the current value */
20577 int (*set_attr)(PyObject *); /* Set the value */
20578 struct swig_globalvar *next;
20579 } swig_globalvar;
20580
20581 typedef struct swig_varlinkobject {
20582 PyObject_HEAD
20583 swig_globalvar *vars;
20584 } swig_varlinkobject;
20585
20586 SWIGINTERN PyObject *
20587 swig_varlink_repr(swig_varlinkobject *v) {
20588 v = v;
20589 return PyString_FromString("<Swig global variables>");
20590 }
20591
20592 SWIGINTERN int
20593 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
20594 swig_globalvar *var;
20595 flags = flags;
20596 fprintf(fp,"Swig global variables { ");
20597 for (var = v->vars; var; var=var->next) {
20598 fprintf(fp,"%s", var->name);
20599 if (var->next) fprintf(fp,", ");
20600 }
20601 fprintf(fp," }\n");
20602 return 0;
20603 }
20604
20605 SWIGINTERN PyObject *
20606 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
20607 swig_globalvar *var = v->vars;
20608 while (var) {
20609 if (strcmp(var->name,n) == 0) {
20610 return (*var->get_attr)();
20611 }
20612 var = var->next;
20613 }
20614 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20615 return NULL;
20616 }
20617
20618 SWIGINTERN int
20619 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
20620 swig_globalvar *var = v->vars;
20621 while (var) {
20622 if (strcmp(var->name,n) == 0) {
20623 return (*var->set_attr)(p);
20624 }
20625 var = var->next;
20626 }
20627 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20628 return 1;
20629 }
20630
20631 SWIGINTERN PyTypeObject*
20632 swig_varlink_type(void) {
20633 static char varlink__doc__[] = "Swig var link object";
20634 static PyTypeObject varlink_type
20635 #if !defined(__cplusplus)
20636 ;
20637 static int type_init = 0;
20638 if (!type_init) {
20639 PyTypeObject tmp
20640 #endif
20641 = {
20642 PyObject_HEAD_INIT(&PyType_Type)
20643 0, /* Number of items in variable part (ob_size) */
20644 (char *)"swigvarlink", /* Type name (tp_name) */
20645 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
20646 0, /* Itemsize (tp_itemsize) */
20647 0, /* Deallocator (tp_dealloc) */
20648 (printfunc) swig_varlink_print, /* Print (tp_print) */
20649 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
20650 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
20651 0, /* tp_compare */
20652 (reprfunc) swig_varlink_repr, /* tp_repr */
20653 0, /* tp_as_number */
20654 0, /* tp_as_sequence */
20655 0, /* tp_as_mapping */
20656 0, /* tp_hash */
20657 0, /* tp_call */
20658 0, /* tp_str */
20659 0, /* tp_getattro */
20660 0, /* tp_setattro */
20661 0, /* tp_as_buffer */
20662 0, /* tp_flags */
20663 varlink__doc__, /* tp_doc */
20664 #if PY_VERSION_HEX >= 0x02000000
20665 0, /* tp_traverse */
20666 0, /* tp_clear */
20667 #endif
20668 #if PY_VERSION_HEX >= 0x02010000
20669 0, /* tp_richcompare */
20670 0, /* tp_weaklistoffset */
20671 #endif
20672 #if PY_VERSION_HEX >= 0x02020000
20673 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
20674 #endif
20675 #if PY_VERSION_HEX >= 0x02030000
20676 0, /* tp_del */
20677 #endif
20678 #ifdef COUNT_ALLOCS
20679 0,0,0,0 /* tp_alloc -> tp_next */
20680 #endif
20681 };
20682 #if !defined(__cplusplus)
20683 varlink_type = tmp;
20684 type_init = 1;
20685 }
20686 #endif
20687 return &varlink_type;
20688 }
20689
20690 /* Create a variable linking object for use later */
20691 SWIGINTERN PyObject *
20692 SWIG_Python_newvarlink(void) {
20693 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
20694 if (result) {
20695 result->vars = 0;
20696 }
20697 return ((PyObject*) result);
20698 }
20699
20700 SWIGINTERN void
20701 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
20702 swig_varlinkobject *v = (swig_varlinkobject *) p;
20703 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
20704 if (gv) {
20705 size_t size = strlen(name)+1;
20706 gv->name = (char *)malloc(size);
20707 if (gv->name) {
20708 strncpy(gv->name,name,size);
20709 gv->get_attr = get_attr;
20710 gv->set_attr = set_attr;
20711 gv->next = v->vars;
20712 }
20713 }
20714 v->vars = gv;
20715 }
20716
20717 /* -----------------------------------------------------------------------------
20718 * constants/methods manipulation
20719 * ----------------------------------------------------------------------------- */
20720
20721 /* Install Constants */
20722 SWIGINTERN void
20723 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
20724 PyObject *obj = 0;
20725 size_t i;
20726 for (i = 0; constants[i].type; ++i) {
20727 switch(constants[i].type) {
20728 case SWIG_PY_INT:
20729 obj = PyInt_FromLong(constants[i].lvalue);
20730 break;
20731 case SWIG_PY_FLOAT:
20732 obj = PyFloat_FromDouble(constants[i].dvalue);
20733 break;
20734 case SWIG_PY_STRING:
20735 if (constants[i].pvalue) {
20736 obj = PyString_FromString((char *) constants[i].pvalue);
20737 } else {
20738 Py_INCREF(Py_None);
20739 obj = Py_None;
20740 }
20741 break;
20742 case SWIG_PY_POINTER:
20743 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
20744 break;
20745 case SWIG_PY_BINARY:
20746 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
20747 break;
20748 default:
20749 obj = 0;
20750 break;
20751 }
20752 if (obj) {
20753 PyDict_SetItemString(d,constants[i].name,obj);
20754 Py_DECREF(obj);
20755 }
20756 }
20757 }
20758
20759 /* -----------------------------------------------------------------------------*/
20760 /* Fix SwigMethods to carry the callback ptrs when needed */
20761 /* -----------------------------------------------------------------------------*/
20762
20763 SWIGINTERN void
20764 SWIG_Python_FixMethods(PyMethodDef *methods,
20765 swig_const_info *const_table,
20766 swig_type_info **types,
20767 swig_type_info **types_initial) {
20768 size_t i;
20769 for (i = 0; methods[i].ml_name; ++i) {
20770 char *c = methods[i].ml_doc;
20771 if (c && (c = strstr(c, "swig_ptr: "))) {
20772 int j;
20773 swig_const_info *ci = 0;
20774 char *name = c + 10;
20775 for (j = 0; const_table[j].type; ++j) {
20776 if (strncmp(const_table[j].name, name,
20777 strlen(const_table[j].name)) == 0) {
20778 ci = &(const_table[j]);
20779 break;
20780 }
20781 }
20782 if (ci) {
20783 size_t shift = (ci->ptype) - types;
20784 swig_type_info *ty = types_initial[shift];
20785 size_t ldoc = (c - methods[i].ml_doc);
20786 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
20787 char *ndoc = (char*)malloc(ldoc + lptr + 10);
20788 if (ndoc) {
20789 char *buff = ndoc;
20790 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
20791 if (ptr) {
20792 strncpy(buff, methods[i].ml_doc, ldoc);
20793 buff += ldoc;
20794 strncpy(buff, "swig_ptr: ", 10);
20795 buff += 10;
20796 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
20797 methods[i].ml_doc = ndoc;
20798 }
20799 }
20800 }
20801 }
20802 }
20803 }
20804
20805 /* -----------------------------------------------------------------------------*
20806 * Initialize type list
20807 * -----------------------------------------------------------------------------*/
20808
20809 #ifdef __cplusplus
20810 }
20811 #endif
20812
20813 /* -----------------------------------------------------------------------------*
20814 * Partial Init method
20815 * -----------------------------------------------------------------------------*/
20816
20817 #ifdef __cplusplus
20818 extern "C"
20819 #endif
20820 SWIGEXPORT void SWIG_init(void) {
20821 static PyObject *SWIG_globals = 0;
20822 PyObject *m, *d;
20823 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
20824
20825 /* Fix SwigMethods to carry the callback ptrs when needed */
20826 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
20827
20828 m = Py_InitModule((char *) SWIG_name, SwigMethods);
20829 d = PyModule_GetDict(m);
20830
20831 SWIG_InitializeModule(0);
20832 SWIG_InstallConstants(d,swig_const_table);
20833
20834 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
20835 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
20836 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
20837 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
20838 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
20839 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
20840 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
20841 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
20842 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
20843 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
20844 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
20845 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
20846 {
20847 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_NUMBER_ROWS)));
20848 }
20849 {
20850 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_NUMBER_COLS)));
20851 }
20852 {
20853 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_ROW_HEIGHT)));
20854 }
20855 {
20856 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_COL_WIDTH)));
20857 }
20858 {
20859 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
20860 }
20861 {
20862 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
20863 }
20864 {
20865 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int(static_cast<int >(wxGRID_LABEL_EDGE_ZONE)));
20866 }
20867 {
20868 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_MIN_ROW_HEIGHT)));
20869 }
20870 {
20871 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_MIN_COL_WIDTH)));
20872 }
20873 {
20874 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
20875 }
20876 {
20877 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int(static_cast<int >(wxGridCellAttr::Any)));
20878 }
20879 {
20880 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int(static_cast<int >(wxGridCellAttr::Default)));
20881 }
20882 {
20883 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int(static_cast<int >(wxGridCellAttr::Cell)));
20884 }
20885 {
20886 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int(static_cast<int >(wxGridCellAttr::Row)));
20887 }
20888 {
20889 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int(static_cast<int >(wxGridCellAttr::Col)));
20890 }
20891 {
20892 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int(static_cast<int >(wxGridCellAttr::Merged)));
20893 }
20894 {
20895 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int(static_cast<int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
20896 }
20897 {
20898 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int(static_cast<int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
20899 }
20900 {
20901 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
20902 }
20903 {
20904 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
20905 }
20906 {
20907 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
20908 }
20909 {
20910 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
20911 }
20912 {
20913 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
20914 }
20915 {
20916 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
20917 }
20918 {
20919 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectCells)));
20920 }
20921 {
20922 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectRows)));
20923 }
20924 {
20925 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectColumns)));
20926 }
20927 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
20928 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
20929 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
20930 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
20931 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
20932 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
20933 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
20934 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
20935 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
20936 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
20937 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
20938 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
20939 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
20940 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
20941 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
20942 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
20943 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
20944
20945
20946 }
20947
wxWidgets (Impactor)