]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied patch [ 1263950 ] wxConnection fixes for Unicode
[wxWidgets.git] / wxPython / src / gtk / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[0]
1343 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[1]
1344 #define SWIGTYPE_p_wxGridCellRenderer swig_types[2]
1345 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[3]
1346 #define SWIGTYPE_p_wxGridCellAttr swig_types[4]
1347 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[5]
1348 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[6]
1349 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[7]
1350 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[8]
1351 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[9]
1352 #define SWIGTYPE_p_wxColour swig_types[10]
1353 #define SWIGTYPE_p_wxDC swig_types[11]
1354 #define SWIGTYPE_p_form_ops_t swig_types[12]
1355 #define SWIGTYPE_p_wxDuplexMode swig_types[13]
1356 #define SWIGTYPE_p_wxGridTableMessage swig_types[14]
1357 #define SWIGTYPE_p_wxGrid swig_types[15]
1358 #define SWIGTYPE_p_wxVisualAttributes swig_types[16]
1359 #define SWIGTYPE_p_char swig_types[17]
1360 #define SWIGTYPE_p_wxPanel swig_types[18]
1361 #define SWIGTYPE_p_wxNotifyEvent swig_types[19]
1362 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[20]
1363 #define SWIGTYPE_p_wxSize swig_types[21]
1364 #define SWIGTYPE_p_wxGridCellCoords swig_types[22]
1365 #define SWIGTYPE_p_wxScrolledWindow swig_types[23]
1366 #define SWIGTYPE_p_wxWindow swig_types[24]
1367 #define SWIGTYPE_p_wxFont swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxEvent swig_types[27]
1370 #define SWIGTYPE_p_wxObject swig_types[28]
1371 #define SWIGTYPE_p_wxGridSizeEvent swig_types[29]
1372 #define SWIGTYPE_p_wxRect swig_types[30]
1373 #define SWIGTYPE_p_long swig_types[31]
1374 #define SWIGTYPE_p_wxPaperSize swig_types[32]
1375 #define SWIGTYPE_p_unsigned_int swig_types[33]
1376 #define SWIGTYPE_unsigned_int swig_types[34]
1377 #define SWIGTYPE_p_wxString swig_types[35]
1378 #define SWIGTYPE_p_wxEvtHandler swig_types[36]
1379 #define SWIGTYPE_p_wxPoint swig_types[37]
1380 #define SWIGTYPE_p_wxGridEvent swig_types[38]
1381 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[39]
1382 #define SWIGTYPE_p_wxGridTableBase swig_types[40]
1383 #define SWIGTYPE_p_wxGridCellEditor swig_types[41]
1384 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[42]
1385 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[43]
1386 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[44]
1387 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[45]
1388 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[46]
1389 #define SWIGTYPE_p_wxPyGridTableBase swig_types[47]
1390 #define SWIGTYPE_p_wxGridStringTable swig_types[48]
1391 #define SWIGTYPE_p_unsigned_char swig_types[49]
1392 #define SWIGTYPE_std__ptrdiff_t swig_types[50]
1393 #define SWIGTYPE_ptrdiff_t swig_types[51]
1394 #define SWIGTYPE_p_wxArrayString swig_types[52]
1395 #define SWIGTYPE_p_wxCommandEvent swig_types[53]
1396 #define SWIGTYPE_p_int swig_types[54]
1397 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[55]
1398 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
1399 #define SWIGTYPE_p_wxKeyEvent swig_types[57]
1400 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[58]
1401 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[59]
1402 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[60]
1403 #define SWIGTYPE_p_unsigned_long swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _grid.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_grid
1413
1414 #define SWIG_name "_grid"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418 #include "wx/wxPython/printfw.h"
1419
1420 #include <wx/grid.h>
1421 #include <wx/generic/gridctrl.h>
1422
1423
1424 static const wxString wxPyEmptyString(wxEmptyString);
1425 static const wxString wxPyPanelNameStr(wxPanelNameStr);
1426 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
1427
1428
1429 #define wxPyMake_TEMPLATE(TYPE) \
1430 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
1431 PyObject* target = NULL; \
1432 if (source) { \
1433 /* Check if there is already a pointer to a Python object in the \
1434 OOR data that we can use. */ \
1435 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
1436 if (data) { \
1437 target = data->m_obj; \
1438 if (target) \
1439 Py_INCREF(target); \
1440 } \
1441 /* Otherwise make a new wrapper for it the old fashioned way and \
1442 give it the OOR treatment */ \
1443 if (! target) { \
1444 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
1445 if (target) \
1446 source->SetClientObject(new wxPyOORClientData(target)); \
1447 } \
1448 } else { /* source was NULL so return None. */ \
1449 Py_INCREF(Py_None); target = Py_None; \
1450 } \
1451 return target; \
1452 } \
1453
1454
1455 wxPyMake_TEMPLATE(wxGridCellRenderer)
1456 wxPyMake_TEMPLATE(wxGridCellEditor)
1457 wxPyMake_TEMPLATE(wxGridCellAttr)
1458 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
1459 wxPyMake_TEMPLATE(wxGridTableBase)
1460
1461
1462
1463 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
1464 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1465 wxGridCellAttr* rval = NULL; \
1466 bool found; \
1467 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1468 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1469 PyObject* ro; \
1470 wxGridCellAttr* ptr; \
1471 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
1472 if (ro) { \
1473 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
1474 rval = ptr; \
1475 Py_DECREF(ro); \
1476 } \
1477 } \
1478 wxPyEndBlockThreads(blocked); \
1479 if (! found) \
1480 rval = PCLASS::CBNAME(a, b, c); \
1481 return rval; \
1482 } \
1483 wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1484 return PCLASS::CBNAME(a, b, c); \
1485 }
1486
1487
1488
1489 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
1490 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
1491 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1492 bool found; \
1493 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1494 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1495 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
1496 Py_DECREF(obj); \
1497 } \
1498 wxPyEndBlockThreads(blocked); \
1499 if (! found) \
1500 PCLASS::CBNAME(attr, a, b); \
1501 } \
1502 void base_##CBNAME(wxGridCellAttr *attr, int a, int b) { \
1503 PCLASS::CBNAME(attr, a, b); \
1504 }
1505
1506
1507
1508 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
1509 void CBNAME(wxGridCellAttr *attr, int val) { \
1510 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1511 bool found; \
1512 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1513 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1514 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
1515 Py_DECREF(obj); \
1516 } \
1517 wxPyEndBlockThreads(blocked); \
1518 if (! found) \
1519 PCLASS::CBNAME(attr, val); \
1520 } \
1521 void base_##CBNAME(wxGridCellAttr *attr, int val) { \
1522 PCLASS::CBNAME(attr, val); \
1523 }
1524
1525
1526
1527 #define PYCALLBACK_INT__pure(CBNAME) \
1528 int CBNAME() { \
1529 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1530 int rval = 0; \
1531 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1532 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1533 wxPyEndBlockThreads(blocked); \
1534 return rval; \
1535 }
1536
1537
1538
1539 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
1540 bool CBNAME(int a, int b) { \
1541 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1542 bool rval = 0; \
1543 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1544 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
1545 wxPyEndBlockThreads(blocked); \
1546 return rval; \
1547 }
1548
1549
1550 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
1551 wxString CBNAME(int a, int b) { \
1552 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1553 wxString rval; \
1554 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1555 PyObject* ro; \
1556 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1557 if (ro) { \
1558 rval = Py2wxString(ro); \
1559 Py_DECREF(ro); \
1560 } \
1561 } \
1562 wxPyEndBlockThreads(blocked); \
1563 return rval; \
1564 }
1565
1566
1567 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
1568 void CBNAME(int a, int b, const wxString& c) { \
1569 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1570 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1571 PyObject* s = wx2PyString(c); \
1572 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1573 Py_DECREF(s); \
1574 } \
1575 wxPyEndBlockThreads(blocked); \
1576 }
1577
1578
1579 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
1580 wxString CBNAME(int a, int b) { \
1581 bool found; \
1582 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1583 wxString rval; \
1584 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1585 PyObject* ro; \
1586 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1587 if (ro) { \
1588 rval = Py2wxString(ro); \
1589 Py_DECREF(ro); \
1590 } \
1591 } \
1592 wxPyEndBlockThreads(blocked); \
1593 if (! found) \
1594 rval = PCLASS::CBNAME(a, b); \
1595 return rval; \
1596 } \
1597 wxString base_##CBNAME(int a, int b) { \
1598 return PCLASS::CBNAME(a, b); \
1599 }
1600
1601
1602 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
1603 bool CBNAME(int a, int b, const wxString& c) { \
1604 bool rval = 0; \
1605 bool found; \
1606 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1607 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1608 PyObject* s = wx2PyString(c); \
1609 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1610 Py_DECREF(s); \
1611 } \
1612 wxPyEndBlockThreads(blocked); \
1613 if (! found) \
1614 rval = PCLASS::CBNAME(a,b,c); \
1615 return rval; \
1616 } \
1617 bool base_##CBNAME(int a, int b, const wxString& c) { \
1618 return PCLASS::CBNAME(a,b,c); \
1619 }
1620
1621
1622
1623
1624 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
1625 long CBNAME(int a, int b) { \
1626 long rval; \
1627 bool found; \
1628 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1629 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1630 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1631 wxPyEndBlockThreads(blocked); \
1632 if (! found) \
1633 rval = PCLASS::CBNAME(a,b); \
1634 return rval; \
1635 } \
1636 long base_##CBNAME(int a, int b) { \
1637 return PCLASS::CBNAME(a,b); \
1638 }
1639
1640
1641
1642 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
1643 bool CBNAME(int a, int b) { \
1644 bool rval = 0; \
1645 bool found; \
1646 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1647 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1648 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1649 wxPyEndBlockThreads(blocked); \
1650 if (! found) \
1651 rval = PCLASS::CBNAME(a,b); \
1652 return rval; \
1653 } \
1654 bool base_##CBNAME(int a, int b) { \
1655 return PCLASS::CBNAME(a,b); \
1656 }
1657
1658
1659
1660 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
1661 double CBNAME(int a, int b) { \
1662 bool found; \
1663 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1664 double rval; \
1665 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1666 PyObject* ro; \
1667 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1668 if (ro) { \
1669 PyObject* str = PyObject_Str(ro); \
1670 rval = PyFloat_AsDouble(str); \
1671 Py_DECREF(ro); Py_DECREF(str); \
1672 } \
1673 } \
1674 wxPyEndBlockThreads(blocked); \
1675 if (! found) \
1676 rval = PCLASS::CBNAME(a, b); \
1677 return rval; \
1678 } \
1679 double base_##CBNAME(int a, int b) { \
1680 return PCLASS::CBNAME(a, b); \
1681 }
1682
1683
1684
1685 #define PYCALLBACK__(PCLASS, CBNAME) \
1686 void CBNAME() { \
1687 bool found; \
1688 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1689 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1690 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1691 wxPyEndBlockThreads(blocked); \
1692 if (! found) \
1693 PCLASS::CBNAME(); \
1694 } \
1695 void base_##CBNAME() { \
1696 PCLASS::CBNAME(); \
1697 }
1698
1699
1700
1701
1702 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
1703 bool CBNAME(size_t a, size_t b) { \
1704 bool rval = 0; \
1705 bool found; \
1706 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1707 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1708 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1709 wxPyEndBlockThreads(blocked); \
1710 if (! found) \
1711 rval = PCLASS::CBNAME(a,b); \
1712 return rval; \
1713 } \
1714 bool base_##CBNAME(size_t a, size_t b) { \
1715 return PCLASS::CBNAME(a,b); \
1716 }
1717
1718
1719
1720 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
1721 bool CBNAME(size_t a) { \
1722 bool rval = 0; \
1723 bool found; \
1724 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1725 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1726 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1727 wxPyEndBlockThreads(blocked); \
1728 if (! found) \
1729 rval = PCLASS::CBNAME(a); \
1730 return rval; \
1731 } \
1732 bool base_##CBNAME(size_t a) { \
1733 return PCLASS::CBNAME(a); \
1734 }
1735
1736
1737 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
1738 wxString CBNAME(int a) { \
1739 bool found; \
1740 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1741 wxString rval; \
1742 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1743 PyObject* ro; \
1744 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
1745 if (ro) { \
1746 rval = Py2wxString(ro); \
1747 Py_DECREF(ro); \
1748 } \
1749 } \
1750 wxPyEndBlockThreads(blocked); \
1751 if (! found) \
1752 rval = PCLASS::CBNAME(a); \
1753 return rval; \
1754 } \
1755 wxString base_##CBNAME(int a) { \
1756 return PCLASS::CBNAME(a); \
1757 }
1758
1759
1760 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
1761 void CBNAME(int a, const wxString& c) { \
1762 bool found; \
1763 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1764 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1765 PyObject* s = wx2PyString(c); \
1766 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
1767 Py_DECREF(s); \
1768 } \
1769 wxPyEndBlockThreads(blocked); \
1770 if (! found) \
1771 PCLASS::CBNAME(a,c); \
1772 } \
1773 void base_##CBNAME(int a, const wxString& c) { \
1774 PCLASS::CBNAME(a,c); \
1775 }
1776
1777
1778
1779
1780 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
1781 bool CBNAME() { \
1782 bool rval = 0; \
1783 bool found; \
1784 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1785 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1786 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1787 wxPyEndBlockThreads(blocked); \
1788 if (! found) \
1789 rval = PCLASS::CBNAME(); \
1790 return rval; \
1791 } \
1792 bool base_##CBNAME() { \
1793 return PCLASS::CBNAME(); \
1794 }
1795
1796
1797
1798 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
1799 void CBNAME(size_t a, int b) { \
1800 bool found; \
1801 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1802 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1803 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1804 wxPyEndBlockThreads(blocked); \
1805 if (! found) \
1806 PCLASS::CBNAME(a,b); \
1807 } \
1808 void base_##CBNAME(size_t a, int b) { \
1809 PCLASS::CBNAME(a,b); \
1810 }
1811
1812
1813
1814
1815 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
1816 void CBNAME(int a, int b, long c) { \
1817 bool found; \
1818 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1819 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1820 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1821 wxPyEndBlockThreads(blocked); \
1822 if (! found) \
1823 PCLASS::CBNAME(a,b,c); \
1824 } \
1825 void base_##CBNAME(int a, int b, long c) { \
1826 PCLASS::CBNAME(a,b,c); \
1827 }
1828
1829
1830
1831
1832 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
1833 void CBNAME(int a, int b, double c) { \
1834 bool found; \
1835 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1836 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1837 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
1838 wxPyEndBlockThreads(blocked); \
1839 if (! found) \
1840 PCLASS::CBNAME(a,b,c); \
1841 } \
1842 void base_##CBNAME(int a, int b, double c) { \
1843 PCLASS::CBNAME(a,b,c); \
1844 }
1845
1846
1847
1848 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
1849 void CBNAME(int a, int b, bool c) { \
1850 bool found; \
1851 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1852 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1853 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1854 wxPyEndBlockThreads(blocked); \
1855 if (! found) \
1856 PCLASS::CBNAME(a,b,c); \
1857 } \
1858 void base_##CBNAME(int a, int b, bool c) { \
1859 PCLASS::CBNAME(a,b,c); \
1860 }
1861
1862
1863
1864
1865
1866
1867 SWIGINTERN PyObject *
1868 SWIG_FromCharPtr(const char* cptr)
1869 {
1870 if (cptr) {
1871 size_t size = strlen(cptr);
1872 if (size > INT_MAX) {
1873 return SWIG_NewPointerObj((char*)(cptr),
1874 SWIG_TypeQuery("char *"), 0);
1875 } else {
1876 if (size != 0) {
1877 return PyString_FromStringAndSize(cptr, size);
1878 } else {
1879 return PyString_FromString(cptr);
1880 }
1881 }
1882 }
1883 Py_INCREF(Py_None);
1884 return Py_None;
1885 }
1886
1887
1888 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
1889 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
1890 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
1891 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
1892 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
1893 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
1894 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
1895 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
1896 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
1897 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
1898
1899
1900 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1901 #define SWIG_From_int PyInt_FromLong
1902 /*@@*/
1903
1904 static void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
1905 if (!self->GetClientObject())
1906 self->SetClientObject(new wxPyOORClientData(_self));
1907 }
1908
1909 #include <limits.h>
1910
1911
1912 SWIGINTERN int
1913 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1914 const char *errmsg)
1915 {
1916 if (value < min_value) {
1917 if (errmsg) {
1918 PyErr_Format(PyExc_OverflowError,
1919 "value %ld is less than '%s' minimum %ld",
1920 value, errmsg, min_value);
1921 }
1922 return 0;
1923 } else if (value > max_value) {
1924 if (errmsg) {
1925 PyErr_Format(PyExc_OverflowError,
1926 "value %ld is greater than '%s' maximum %ld",
1927 value, errmsg, max_value);
1928 }
1929 return 0;
1930 }
1931 return 1;
1932 }
1933
1934
1935 SWIGINTERN int
1936 SWIG_AsVal_long(PyObject* obj, long* val)
1937 {
1938 if (PyNumber_Check(obj)) {
1939 if (val) *val = PyInt_AsLong(obj);
1940 return 1;
1941 }
1942 else {
1943 SWIG_type_error("number", obj);
1944 }
1945 return 0;
1946 }
1947
1948
1949 #if INT_MAX != LONG_MAX
1950 SWIGINTERN int
1951 SWIG_AsVal_int(PyObject *obj, int *val)
1952 {
1953 const char* errmsg = val ? "int" : (char*)0;
1954 long v;
1955 if (SWIG_AsVal_long(obj, &v)) {
1956 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1957 if (val) *val = (int)(v);
1958 return 1;
1959 } else {
1960 return 0;
1961 }
1962 } else {
1963 PyErr_Clear();
1964 }
1965 if (val) {
1966 SWIG_type_error(errmsg, obj);
1967 }
1968 return 0;
1969 }
1970 #else
1971 SWIGINTERNSHORT int
1972 SWIG_AsVal_int(PyObject *obj, int *val)
1973 {
1974 return SWIG_AsVal_long(obj,(long*)val);
1975 }
1976 #endif
1977
1978
1979 SWIGINTERNSHORT int
1980 SWIG_As_int(PyObject* obj)
1981 {
1982 int v;
1983 if (!SWIG_AsVal_int(obj, &v)) {
1984 /*
1985 this is needed to make valgrind/purify happier.
1986 */
1987 memset((void*)&v, 0, sizeof(int));
1988 }
1989 return v;
1990 }
1991
1992
1993 SWIGINTERN int
1994 SWIG_AsVal_bool(PyObject *obj, bool *val)
1995 {
1996 if (obj == Py_True) {
1997 if (val) *val = true;
1998 return 1;
1999 }
2000 if (obj == Py_False) {
2001 if (val) *val = false;
2002 return 1;
2003 }
2004 int res = 0;
2005 if (SWIG_AsVal_int(obj, &res)) {
2006 if (val) *val = res ? true : false;
2007 return 1;
2008 } else {
2009 PyErr_Clear();
2010 }
2011 if (val) {
2012 SWIG_type_error("bool", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERNSHORT bool
2019 SWIG_As_bool(PyObject* obj)
2020 {
2021 bool v;
2022 if (!SWIG_AsVal_bool(obj, &v)) {
2023 /*
2024 this is needed to make valgrind/purify happier.
2025 */
2026 memset((void*)&v, 0, sizeof(bool));
2027 }
2028 return v;
2029 }
2030
2031
2032 SWIGINTERNSHORT int
2033 SWIG_Check_int(PyObject* obj)
2034 {
2035 return SWIG_AsVal_int(obj, (int*)0);
2036 }
2037
2038
2039 SWIGINTERNSHORT int
2040 SWIG_Check_bool(PyObject* obj)
2041 {
2042 return SWIG_AsVal_bool(obj, (bool*)0);
2043 }
2044
2045
2046 class wxPyGridCellRenderer : public wxGridCellRenderer
2047 {
2048 public:
2049 wxPyGridCellRenderer() : wxGridCellRenderer() {};
2050
2051 // Implement Python callback aware virtual methods
2052 void Draw(wxGrid& grid, wxGridCellAttr& attr,
2053 wxDC& dc, const wxRect& rect,
2054 int row, int col, bool isSelected) {
2055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2056 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
2057 PyObject* go = wxPyMake_wxObject(&grid,false);
2058 PyObject* dco = wxPyMake_wxObject(&dc,false);
2059 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2060 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
2061
2062 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
2063 row, col, isSelected));
2064 Py_DECREF(go);
2065 Py_DECREF(ao);
2066 Py_DECREF(dco);
2067 Py_DECREF(ro);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 }
2071
2072 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
2073 int row, int col) {
2074 wxSize rval;
2075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2076 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
2077 PyObject* ro;
2078 wxSize* ptr;
2079 PyObject* go = wxPyMake_wxObject(&grid,false);
2080 PyObject* dco = wxPyMake_wxObject(&dc,false);
2081 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2082
2083 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
2084 go, ao, dco,
2085 row, col));
2086 Py_DECREF(go);
2087 Py_DECREF(ao);
2088 Py_DECREF(dco);
2089
2090 if (ro) {
2091 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
2092 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
2093 rval = *ptr;
2094 }
2095 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
2096 PyObject* o1 = PySequence_GetItem(ro, 0);
2097 PyObject* o2 = PySequence_GetItem(ro, 1);
2098 if (PyNumber_Check(o1) && PyNumber_Check(o2))
2099 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
2100 else
2101 PyErr_SetString(PyExc_TypeError, errmsg);
2102 Py_DECREF(o1);
2103 Py_DECREF(o2);
2104 }
2105 else {
2106 PyErr_SetString(PyExc_TypeError, errmsg);
2107 }
2108 Py_DECREF(ro);
2109 }
2110 }
2111 wxPyEndBlockThreads(blocked);
2112 return rval;
2113 }
2114
2115
2116 wxGridCellRenderer *Clone() const {
2117 wxGridCellRenderer* rval = NULL;
2118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2119 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2120 PyObject* ro;
2121 wxGridCellRenderer* ptr;
2122 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2123 if (ro) {
2124 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
2125 rval = ptr;
2126 Py_DECREF(ro);
2127 }
2128 }
2129 wxPyEndBlockThreads(blocked);
2130 return rval;
2131 }
2132
2133 DEC_PYCALLBACK__STRING(SetParameters);
2134
2135 PYPRIVATE;
2136 };
2137
2138 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
2139
2140
2141 static void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
2142 if (!self->GetClientObject())
2143 self->SetClientObject(new wxPyOORClientData(_self));
2144 }
2145
2146 class wxPyGridCellEditor : public wxGridCellEditor
2147 {
2148 public:
2149 wxPyGridCellEditor() : wxGridCellEditor() {}
2150
2151 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
2152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2153 if (wxPyCBH_findCallback(m_myInst, "Create")) {
2154 PyObject* po = wxPyMake_wxObject(parent,false);
2155 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
2156
2157 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
2158 Py_DECREF(po);
2159 Py_DECREF(eo);
2160 }
2161 wxPyEndBlockThreads(blocked);
2162 }
2163
2164
2165 void BeginEdit(int row, int col, wxGrid* grid) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
2168 PyObject* go = wxPyMake_wxObject(grid,false);
2169 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2170 Py_DECREF(go);
2171 }
2172 wxPyEndBlockThreads(blocked);
2173 }
2174
2175
2176 bool EndEdit(int row, int col, wxGrid* grid) {
2177 bool rv = false;
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
2180 PyObject* go = wxPyMake_wxObject(grid,false);
2181 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2182 Py_DECREF(go);
2183 }
2184 wxPyEndBlockThreads(blocked);
2185 return rv;
2186 }
2187
2188
2189 wxGridCellEditor* Clone() const {
2190 wxGridCellEditor* rval = NULL;
2191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2192 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2193 PyObject* ro;
2194 wxGridCellEditor* ptr;
2195 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2196 if (ro) {
2197 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
2198 rval = ptr;
2199 Py_DECREF(ro);
2200 }
2201 }
2202 wxPyEndBlockThreads(blocked);
2203 return rval;
2204 }
2205
2206
2207 void Show(bool show, wxGridCellAttr *attr) {
2208 bool found;
2209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2210 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
2211 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2212 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
2213 Py_DECREF(ao);
2214 }
2215 wxPyEndBlockThreads(blocked);
2216 if (! found)
2217 wxGridCellEditor::Show(show, attr);
2218 }
2219 void base_Show(bool show, wxGridCellAttr *attr) {
2220 wxGridCellEditor::Show(show, attr);
2221 }
2222
2223
2224 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2225 bool found;
2226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2227 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
2228 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2229 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
2230
2231 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
2232
2233 Py_DECREF(ro);
2234 Py_DECREF(ao);
2235 }
2236 wxPyEndBlockThreads(blocked);
2237 if (! found)
2238 wxGridCellEditor::PaintBackground(rectCell, attr);
2239 }
2240 void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2241 wxGridCellEditor::PaintBackground(rectCell, attr);
2242 }
2243
2244
2245 DEC_PYCALLBACK___pure(Reset);
2246 DEC_PYCALLBACK__constany(SetSize, wxRect);
2247 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
2248 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
2249 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
2250 DEC_PYCALLBACK__(StartingClick);
2251 DEC_PYCALLBACK__(Destroy);
2252 DEC_PYCALLBACK__STRING(SetParameters);
2253 DEC_PYCALLBACK_STRING__constpure(GetValue);
2254
2255 PYPRIVATE;
2256 };
2257
2258
2259 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
2260 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
2261 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
2262 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
2263 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
2264 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
2265 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
2266 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
2267 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
2268
2269
2270 static void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
2271 if (!self->GetClientObject())
2272 self->SetClientObject(new wxPyOORClientData(_self));
2273 }
2274
2275 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2276 PyObject* o2;
2277 PyObject* o3;
2278
2279 if (!target) {
2280 target = o;
2281 } else if (target == Py_None) {
2282 Py_DECREF(Py_None);
2283 target = o;
2284 } else {
2285 if (!PyTuple_Check(target)) {
2286 o2 = target;
2287 target = PyTuple_New(1);
2288 PyTuple_SetItem(target, 0, o2);
2289 }
2290 o3 = PyTuple_New(1);
2291 PyTuple_SetItem(o3, 0, o);
2292
2293 o2 = target;
2294 target = PySequence_Concat(o2, o3);
2295 Py_DECREF(o2);
2296 Py_DECREF(o3);
2297 }
2298 return target;
2299 }
2300
2301
2302 static void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
2303 if (!self->GetClientObject())
2304 self->SetClientObject(new wxPyOORClientData(_self));
2305 }
2306
2307 SWIGINTERN int
2308 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2309 {
2310 long v = 0;
2311 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2312 SWIG_type_error("unsigned number", obj);
2313 }
2314 else if (val)
2315 *val = (unsigned long)v;
2316 return 1;
2317 }
2318
2319
2320 SWIGINTERNSHORT unsigned long
2321 SWIG_As_unsigned_SS_long(PyObject* obj)
2322 {
2323 unsigned long v;
2324 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2325 /*
2326 this is needed to make valgrind/purify happier.
2327 */
2328 memset((void*)&v, 0, sizeof(unsigned long));
2329 }
2330 return v;
2331 }
2332
2333
2334 SWIGINTERNSHORT int
2335 SWIG_Check_unsigned_SS_long(PyObject* obj)
2336 {
2337 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2338 }
2339
2340
2341 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
2342 {
2343 public:
2344 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
2345
2346 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
2347 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
2348 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
2349 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
2350
2351 PYPRIVATE;
2352 };
2353
2354 static void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
2355 if (!self->GetClientObject())
2356 self->SetClientObject(new wxPyOORClientData(_self));
2357 }
2358
2359 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2360 #define SWIG_From_long PyInt_FromLong
2361 /*@@*/
2362
2363
2364 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2365 #define SWIG_From_double PyFloat_FromDouble
2366 /*@@*/
2367
2368
2369 SWIGINTERNSHORT long
2370 SWIG_As_long(PyObject* obj)
2371 {
2372 long v;
2373 if (!SWIG_AsVal_long(obj, &v)) {
2374 /*
2375 this is needed to make valgrind/purify happier.
2376 */
2377 memset((void*)&v, 0, sizeof(long));
2378 }
2379 return v;
2380 }
2381
2382
2383 SWIGINTERNSHORT int
2384 SWIG_Check_long(PyObject* obj)
2385 {
2386 return SWIG_AsVal_long(obj, (long*)0);
2387 }
2388
2389
2390 SWIGINTERN int
2391 SWIG_AsVal_double(PyObject *obj, double* val)
2392 {
2393 if (PyNumber_Check(obj)) {
2394 if (val) *val = PyFloat_AsDouble(obj);
2395 return 1;
2396 }
2397 else {
2398 SWIG_type_error("number", obj);
2399 }
2400 return 0;
2401 }
2402
2403
2404 SWIGINTERNSHORT double
2405 SWIG_As_double(PyObject* obj)
2406 {
2407 double v;
2408 if (!SWIG_AsVal_double(obj, &v)) {
2409 /*
2410 this is needed to make valgrind/purify happier.
2411 */
2412 memset((void*)&v, 0, sizeof(double));
2413 }
2414 return v;
2415 }
2416
2417
2418 SWIGINTERNSHORT int
2419 SWIG_Check_double(PyObject* obj)
2420 {
2421 return SWIG_AsVal_double(obj, (double*)0);
2422 }
2423
2424
2425 class wxPyGridTableBase : public wxGridTableBase
2426 {
2427 public:
2428 wxPyGridTableBase() : wxGridTableBase() {}
2429
2430 PYCALLBACK_INT__pure(GetNumberRows);
2431 PYCALLBACK_INT__pure(GetNumberCols);
2432 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
2433 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
2434 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
2435 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
2436 PYCALLBACK__(wxGridTableBase, Clear);
2437 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
2438 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
2439 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
2440 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
2441 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
2442 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
2443 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
2444 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
2445 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
2446 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
2447 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
2448 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
2449 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
2450 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
2451 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
2452
2453
2454 wxString GetValue(int row, int col) {
2455 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2456 wxString rval;
2457 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2458 PyObject* ro;
2459 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
2460 if (ro) {
2461 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
2462 PyObject* old = ro;
2463 ro = PyObject_Str(ro);
2464 Py_DECREF(old);
2465 }
2466 rval = Py2wxString(ro);
2467 Py_DECREF(ro);
2468 }
2469 }
2470 wxPyEndBlockThreads(blocked);
2471 return rval;
2472 }
2473
2474 void SetValue(int row, int col, const wxString& val) {
2475 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2476 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2477 PyObject* s = wx2PyString(val);
2478 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
2479 Py_DECREF(s);
2480 }
2481 wxPyEndBlockThreads(blocked);
2482 }
2483
2484
2485 // Map the Get/Set methods for the standard non-string types to
2486 // the GetValue and SetValue python methods.
2487 long GetValueAsLong( int row, int col ) {
2488 long rval = 0;
2489 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2490 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2491 PyObject* ro;
2492 PyObject* num;
2493 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2494 if (ro && PyNumber_Check(ro)) {
2495 num = PyNumber_Int(ro);
2496 if (num) {
2497 rval = PyInt_AsLong(num);
2498 Py_DECREF(num);
2499 }
2500 Py_DECREF(ro);
2501 }
2502 }
2503 wxPyEndBlockThreads(blocked);
2504 return rval;
2505 }
2506
2507 double GetValueAsDouble( int row, int col ) {
2508 double rval = 0.0;
2509 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2510 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2511 PyObject* ro;
2512 PyObject* num;
2513 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2514 if (ro && PyNumber_Check(ro)) {
2515 num = PyNumber_Float(ro);
2516 if (num) {
2517 rval = PyFloat_AsDouble(num);
2518 Py_DECREF(num);
2519 }
2520 Py_DECREF(ro);
2521 }
2522 }
2523 wxPyEndBlockThreads(blocked);
2524 return rval;
2525 }
2526
2527 bool GetValueAsBool( int row, int col ) {
2528 return (bool)GetValueAsLong(row, col);
2529 }
2530
2531 void SetValueAsLong( int row, int col, long value ) {
2532 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2533 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2534 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
2535 }
2536 wxPyEndBlockThreads(blocked);
2537 }
2538
2539 void SetValueAsDouble( int row, int col, double value ) {
2540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2541 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2542 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
2543 }
2544 wxPyEndBlockThreads(blocked);
2545 }
2546
2547 void SetValueAsBool( int row, int col, bool value ) {
2548 SetValueAsLong( row, col, (long)value );
2549 }
2550
2551
2552 PYPRIVATE;
2553 };
2554
2555 static void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
2556
2557 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
2558
2559 if (source == Py_None) {
2560 **obj = wxGridCellCoords(-1,-1);
2561 return true;
2562 }
2563
2564 // If source is an object instance then it may already be the right type
2565 if (wxPySwigInstance_Check(source)) {
2566 wxGridCellCoords* ptr;
2567 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2568 goto error;
2569 *obj = ptr;
2570 return true;
2571 }
2572 // otherwise a 2-tuple of integers is expected
2573 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2574 PyObject* o1 = PySequence_GetItem(source, 0);
2575 PyObject* o2 = PySequence_GetItem(source, 1);
2576 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2577 Py_DECREF(o1);
2578 Py_DECREF(o2);
2579 goto error;
2580 }
2581 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
2582 Py_DECREF(o1);
2583 Py_DECREF(o2);
2584 return true;
2585 }
2586
2587 error:
2588 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
2589 return false;
2590 }
2591
2592
2593 bool wxGridCellCoords_typecheck(PyObject* source) {
2594 void* ptr;
2595
2596 if (wxPySwigInstance_Check(source) &&
2597 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2598 return true;
2599
2600 PyErr_Clear();
2601 if (PySequence_Check(source) && PySequence_Length(source) == 2)
2602 return true;
2603
2604 return false;
2605 }
2606
2607
2608 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
2609 {
2610 PyObject* list = PyList_New(0);
2611 size_t idx;
2612 for (idx = 0; idx < source.GetCount(); idx += 1) {
2613 wxGridCellCoords& coord = source.Item(idx);
2614 PyObject* tup = PyTuple_New(2);
2615 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
2616 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
2617 PyList_Append(list, tup);
2618 Py_DECREF(tup);
2619 }
2620 return list;
2621 }
2622
2623 static PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
2624 PyObject* tup = PyTuple_New(2);
2625 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
2626 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
2627 return tup;
2628 }
2629
2630 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
2631
2632
2633 static wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
2634 wxGridCellCoords rv;
2635 self->XYToCell(x, y, rv);
2636 return rv;
2637 }
2638 #ifdef __cplusplus
2639 extern "C" {
2640 #endif
2641 static int _wrap_GridNoCellCoords_set(PyObject *) {
2642 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2643 return 1;
2644 }
2645
2646
2647 static PyObject *_wrap_GridNoCellCoords_get(void) {
2648 PyObject *pyobj;
2649
2650 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2651 return pyobj;
2652 }
2653
2654
2655 static int _wrap_GridNoCellRect_set(PyObject *) {
2656 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2657 return 1;
2658 }
2659
2660
2661 static PyObject *_wrap_GridNoCellRect_get(void) {
2662 PyObject *pyobj;
2663
2664 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2665 return pyobj;
2666 }
2667
2668
2669 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2670 PyObject *resultobj;
2671 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2672 PyObject *arg2 = (PyObject *) 0 ;
2673 PyObject * obj0 = 0 ;
2674 PyObject * obj1 = 0 ;
2675 char *kwnames[] = {
2676 (char *) "self",(char *) "_self", NULL
2677 };
2678
2679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2681 if (SWIG_arg_fail(1)) SWIG_fail;
2682 arg2 = obj1;
2683 {
2684 PyThreadState* __tstate = wxPyBeginAllowThreads();
2685 wxGridCellRenderer__setOORInfo(arg1,arg2);
2686
2687 wxPyEndAllowThreads(__tstate);
2688 if (PyErr_Occurred()) SWIG_fail;
2689 }
2690 Py_INCREF(Py_None); resultobj = Py_None;
2691 return resultobj;
2692 fail:
2693 return NULL;
2694 }
2695
2696
2697 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2698 PyObject *resultobj;
2699 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2700 wxString *arg2 = 0 ;
2701 bool temp2 = false ;
2702 PyObject * obj0 = 0 ;
2703 PyObject * obj1 = 0 ;
2704 char *kwnames[] = {
2705 (char *) "self",(char *) "params", NULL
2706 };
2707
2708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2710 if (SWIG_arg_fail(1)) SWIG_fail;
2711 {
2712 arg2 = wxString_in_helper(obj1);
2713 if (arg2 == NULL) SWIG_fail;
2714 temp2 = true;
2715 }
2716 {
2717 PyThreadState* __tstate = wxPyBeginAllowThreads();
2718 (arg1)->SetParameters((wxString const &)*arg2);
2719
2720 wxPyEndAllowThreads(__tstate);
2721 if (PyErr_Occurred()) SWIG_fail;
2722 }
2723 Py_INCREF(Py_None); resultobj = Py_None;
2724 {
2725 if (temp2)
2726 delete arg2;
2727 }
2728 return resultobj;
2729 fail:
2730 {
2731 if (temp2)
2732 delete arg2;
2733 }
2734 return NULL;
2735 }
2736
2737
2738 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2739 PyObject *resultobj;
2740 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2741 PyObject * obj0 = 0 ;
2742 char *kwnames[] = {
2743 (char *) "self", NULL
2744 };
2745
2746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2748 if (SWIG_arg_fail(1)) SWIG_fail;
2749 {
2750 PyThreadState* __tstate = wxPyBeginAllowThreads();
2751 (arg1)->IncRef();
2752
2753 wxPyEndAllowThreads(__tstate);
2754 if (PyErr_Occurred()) SWIG_fail;
2755 }
2756 Py_INCREF(Py_None); resultobj = Py_None;
2757 return resultobj;
2758 fail:
2759 return NULL;
2760 }
2761
2762
2763 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2764 PyObject *resultobj;
2765 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2766 PyObject * obj0 = 0 ;
2767 char *kwnames[] = {
2768 (char *) "self", NULL
2769 };
2770
2771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2773 if (SWIG_arg_fail(1)) SWIG_fail;
2774 {
2775 PyThreadState* __tstate = wxPyBeginAllowThreads();
2776 (arg1)->DecRef();
2777
2778 wxPyEndAllowThreads(__tstate);
2779 if (PyErr_Occurred()) SWIG_fail;
2780 }
2781 Py_INCREF(Py_None); resultobj = Py_None;
2782 return resultobj;
2783 fail:
2784 return NULL;
2785 }
2786
2787
2788 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
2789 PyObject *resultobj;
2790 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2791 wxGrid *arg2 = 0 ;
2792 wxGridCellAttr *arg3 = 0 ;
2793 wxDC *arg4 = 0 ;
2794 wxRect *arg5 = 0 ;
2795 int arg6 ;
2796 int arg7 ;
2797 bool arg8 ;
2798 wxRect temp5 ;
2799 PyObject * obj0 = 0 ;
2800 PyObject * obj1 = 0 ;
2801 PyObject * obj2 = 0 ;
2802 PyObject * obj3 = 0 ;
2803 PyObject * obj4 = 0 ;
2804 PyObject * obj5 = 0 ;
2805 PyObject * obj6 = 0 ;
2806 PyObject * obj7 = 0 ;
2807 char *kwnames[] = {
2808 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
2809 };
2810
2811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2813 if (SWIG_arg_fail(1)) SWIG_fail;
2814 {
2815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2816 if (SWIG_arg_fail(2)) SWIG_fail;
2817 if (arg2 == NULL) {
2818 SWIG_null_ref("wxGrid");
2819 }
2820 if (SWIG_arg_fail(2)) SWIG_fail;
2821 }
2822 {
2823 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2824 if (SWIG_arg_fail(3)) SWIG_fail;
2825 if (arg3 == NULL) {
2826 SWIG_null_ref("wxGridCellAttr");
2827 }
2828 if (SWIG_arg_fail(3)) SWIG_fail;
2829 }
2830 {
2831 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(4)) SWIG_fail;
2833 if (arg4 == NULL) {
2834 SWIG_null_ref("wxDC");
2835 }
2836 if (SWIG_arg_fail(4)) SWIG_fail;
2837 }
2838 {
2839 arg5 = &temp5;
2840 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
2841 }
2842 {
2843 arg6 = (int)(SWIG_As_int(obj5));
2844 if (SWIG_arg_fail(6)) SWIG_fail;
2845 }
2846 {
2847 arg7 = (int)(SWIG_As_int(obj6));
2848 if (SWIG_arg_fail(7)) SWIG_fail;
2849 }
2850 {
2851 arg8 = (bool)(SWIG_As_bool(obj7));
2852 if (SWIG_arg_fail(8)) SWIG_fail;
2853 }
2854 {
2855 PyThreadState* __tstate = wxPyBeginAllowThreads();
2856 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
2857
2858 wxPyEndAllowThreads(__tstate);
2859 if (PyErr_Occurred()) SWIG_fail;
2860 }
2861 Py_INCREF(Py_None); resultobj = Py_None;
2862 return resultobj;
2863 fail:
2864 return NULL;
2865 }
2866
2867
2868 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
2869 PyObject *resultobj;
2870 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2871 wxGrid *arg2 = 0 ;
2872 wxGridCellAttr *arg3 = 0 ;
2873 wxDC *arg4 = 0 ;
2874 int arg5 ;
2875 int arg6 ;
2876 wxSize result;
2877 PyObject * obj0 = 0 ;
2878 PyObject * obj1 = 0 ;
2879 PyObject * obj2 = 0 ;
2880 PyObject * obj3 = 0 ;
2881 PyObject * obj4 = 0 ;
2882 PyObject * obj5 = 0 ;
2883 char *kwnames[] = {
2884 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
2885 };
2886
2887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2889 if (SWIG_arg_fail(1)) SWIG_fail;
2890 {
2891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(2)) SWIG_fail;
2893 if (arg2 == NULL) {
2894 SWIG_null_ref("wxGrid");
2895 }
2896 if (SWIG_arg_fail(2)) SWIG_fail;
2897 }
2898 {
2899 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2900 if (SWIG_arg_fail(3)) SWIG_fail;
2901 if (arg3 == NULL) {
2902 SWIG_null_ref("wxGridCellAttr");
2903 }
2904 if (SWIG_arg_fail(3)) SWIG_fail;
2905 }
2906 {
2907 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2908 if (SWIG_arg_fail(4)) SWIG_fail;
2909 if (arg4 == NULL) {
2910 SWIG_null_ref("wxDC");
2911 }
2912 if (SWIG_arg_fail(4)) SWIG_fail;
2913 }
2914 {
2915 arg5 = (int)(SWIG_As_int(obj4));
2916 if (SWIG_arg_fail(5)) SWIG_fail;
2917 }
2918 {
2919 arg6 = (int)(SWIG_As_int(obj5));
2920 if (SWIG_arg_fail(6)) SWIG_fail;
2921 }
2922 {
2923 PyThreadState* __tstate = wxPyBeginAllowThreads();
2924 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
2925
2926 wxPyEndAllowThreads(__tstate);
2927 if (PyErr_Occurred()) SWIG_fail;
2928 }
2929 {
2930 wxSize * resultptr;
2931 resultptr = new wxSize((wxSize &)(result));
2932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2933 }
2934 return resultobj;
2935 fail:
2936 return NULL;
2937 }
2938
2939
2940 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
2941 PyObject *resultobj;
2942 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2943 wxGridCellRenderer *result;
2944 PyObject * obj0 = 0 ;
2945 char *kwnames[] = {
2946 (char *) "self", NULL
2947 };
2948
2949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
2950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2951 if (SWIG_arg_fail(1)) SWIG_fail;
2952 {
2953 PyThreadState* __tstate = wxPyBeginAllowThreads();
2954 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
2955
2956 wxPyEndAllowThreads(__tstate);
2957 if (PyErr_Occurred()) SWIG_fail;
2958 }
2959 {
2960 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
2961 }
2962 return resultobj;
2963 fail:
2964 return NULL;
2965 }
2966
2967
2968 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
2969 PyObject *obj;
2970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2971 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
2972 Py_INCREF(obj);
2973 return Py_BuildValue((char *)"");
2974 }
2975 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
2976 PyObject *resultobj;
2977 wxPyGridCellRenderer *result;
2978 char *kwnames[] = {
2979 NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
2983 {
2984 PyThreadState* __tstate = wxPyBeginAllowThreads();
2985 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
2986
2987 wxPyEndAllowThreads(__tstate);
2988 if (PyErr_Occurred()) SWIG_fail;
2989 }
2990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
2991 return resultobj;
2992 fail:
2993 return NULL;
2994 }
2995
2996
2997 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2998 PyObject *resultobj;
2999 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3000 PyObject *arg2 = (PyObject *) 0 ;
3001 PyObject *arg3 = (PyObject *) 0 ;
3002 PyObject * obj0 = 0 ;
3003 PyObject * obj1 = 0 ;
3004 PyObject * obj2 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self",(char *) "self",(char *) "_class", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 arg2 = obj1;
3013 arg3 = obj2;
3014 {
3015 PyThreadState* __tstate = wxPyBeginAllowThreads();
3016 (arg1)->_setCallbackInfo(arg2,arg3);
3017
3018 wxPyEndAllowThreads(__tstate);
3019 if (PyErr_Occurred()) SWIG_fail;
3020 }
3021 Py_INCREF(Py_None); resultobj = Py_None;
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject *_wrap_PyGridCellRenderer_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3029 PyObject *resultobj;
3030 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3031 wxString *arg2 = 0 ;
3032 bool temp2 = false ;
3033 PyObject * obj0 = 0 ;
3034 PyObject * obj1 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "self",(char *) "params", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 {
3043 arg2 = wxString_in_helper(obj1);
3044 if (arg2 == NULL) SWIG_fail;
3045 temp2 = true;
3046 }
3047 {
3048 PyThreadState* __tstate = wxPyBeginAllowThreads();
3049 (arg1)->base_SetParameters((wxString const &)*arg2);
3050
3051 wxPyEndAllowThreads(__tstate);
3052 if (PyErr_Occurred()) SWIG_fail;
3053 }
3054 Py_INCREF(Py_None); resultobj = Py_None;
3055 {
3056 if (temp2)
3057 delete arg2;
3058 }
3059 return resultobj;
3060 fail:
3061 {
3062 if (temp2)
3063 delete arg2;
3064 }
3065 return NULL;
3066 }
3067
3068
3069 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3070 PyObject *obj;
3071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3072 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3073 Py_INCREF(obj);
3074 return Py_BuildValue((char *)"");
3075 }
3076 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3077 PyObject *resultobj;
3078 wxGridCellStringRenderer *result;
3079 char *kwnames[] = {
3080 NULL
3081 };
3082
3083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3084 {
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3099 PyObject *obj;
3100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3101 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3102 Py_INCREF(obj);
3103 return Py_BuildValue((char *)"");
3104 }
3105 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3106 PyObject *resultobj;
3107 wxGridCellNumberRenderer *result;
3108 char *kwnames[] = {
3109 NULL
3110 };
3111
3112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3113 {
3114 PyThreadState* __tstate = wxPyBeginAllowThreads();
3115 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3116
3117 wxPyEndAllowThreads(__tstate);
3118 if (PyErr_Occurred()) SWIG_fail;
3119 }
3120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3121 return resultobj;
3122 fail:
3123 return NULL;
3124 }
3125
3126
3127 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3128 PyObject *obj;
3129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3130 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3131 Py_INCREF(obj);
3132 return Py_BuildValue((char *)"");
3133 }
3134 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 int arg1 = (int) -1 ;
3137 int arg2 = (int) -1 ;
3138 wxGridCellFloatRenderer *result;
3139 PyObject * obj0 = 0 ;
3140 PyObject * obj1 = 0 ;
3141 char *kwnames[] = {
3142 (char *) "width",(char *) "precision", NULL
3143 };
3144
3145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3146 if (obj0) {
3147 {
3148 arg1 = (int)(SWIG_As_int(obj0));
3149 if (SWIG_arg_fail(1)) SWIG_fail;
3150 }
3151 }
3152 if (obj1) {
3153 {
3154 arg2 = (int)(SWIG_As_int(obj1));
3155 if (SWIG_arg_fail(2)) SWIG_fail;
3156 }
3157 }
3158 {
3159 PyThreadState* __tstate = wxPyBeginAllowThreads();
3160 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3161
3162 wxPyEndAllowThreads(__tstate);
3163 if (PyErr_Occurred()) SWIG_fail;
3164 }
3165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3166 return resultobj;
3167 fail:
3168 return NULL;
3169 }
3170
3171
3172 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3173 PyObject *resultobj;
3174 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3175 int result;
3176 PyObject * obj0 = 0 ;
3177 char *kwnames[] = {
3178 (char *) "self", NULL
3179 };
3180
3181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3183 if (SWIG_arg_fail(1)) SWIG_fail;
3184 {
3185 PyThreadState* __tstate = wxPyBeginAllowThreads();
3186 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3187
3188 wxPyEndAllowThreads(__tstate);
3189 if (PyErr_Occurred()) SWIG_fail;
3190 }
3191 {
3192 resultobj = SWIG_From_int((int)(result));
3193 }
3194 return resultobj;
3195 fail:
3196 return NULL;
3197 }
3198
3199
3200 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3201 PyObject *resultobj;
3202 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3203 int arg2 ;
3204 PyObject * obj0 = 0 ;
3205 PyObject * obj1 = 0 ;
3206 char *kwnames[] = {
3207 (char *) "self",(char *) "width", NULL
3208 };
3209
3210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3212 if (SWIG_arg_fail(1)) SWIG_fail;
3213 {
3214 arg2 = (int)(SWIG_As_int(obj1));
3215 if (SWIG_arg_fail(2)) SWIG_fail;
3216 }
3217 {
3218 PyThreadState* __tstate = wxPyBeginAllowThreads();
3219 (arg1)->SetWidth(arg2);
3220
3221 wxPyEndAllowThreads(__tstate);
3222 if (PyErr_Occurred()) SWIG_fail;
3223 }
3224 Py_INCREF(Py_None); resultobj = Py_None;
3225 return resultobj;
3226 fail:
3227 return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3232 PyObject *resultobj;
3233 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3234 int result;
3235 PyObject * obj0 = 0 ;
3236 char *kwnames[] = {
3237 (char *) "self", NULL
3238 };
3239
3240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3242 if (SWIG_arg_fail(1)) SWIG_fail;
3243 {
3244 PyThreadState* __tstate = wxPyBeginAllowThreads();
3245 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3246
3247 wxPyEndAllowThreads(__tstate);
3248 if (PyErr_Occurred()) SWIG_fail;
3249 }
3250 {
3251 resultobj = SWIG_From_int((int)(result));
3252 }
3253 return resultobj;
3254 fail:
3255 return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3260 PyObject *resultobj;
3261 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3262 int arg2 ;
3263 PyObject * obj0 = 0 ;
3264 PyObject * obj1 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self",(char *) "precision", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 arg2 = (int)(SWIG_As_int(obj1));
3274 if (SWIG_arg_fail(2)) SWIG_fail;
3275 }
3276 {
3277 PyThreadState* __tstate = wxPyBeginAllowThreads();
3278 (arg1)->SetPrecision(arg2);
3279
3280 wxPyEndAllowThreads(__tstate);
3281 if (PyErr_Occurred()) SWIG_fail;
3282 }
3283 Py_INCREF(Py_None); resultobj = Py_None;
3284 return resultobj;
3285 fail:
3286 return NULL;
3287 }
3288
3289
3290 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3291 PyObject *obj;
3292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3293 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3294 Py_INCREF(obj);
3295 return Py_BuildValue((char *)"");
3296 }
3297 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3298 PyObject *resultobj;
3299 wxGridCellBoolRenderer *result;
3300 char *kwnames[] = {
3301 NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3305 {
3306 PyThreadState* __tstate = wxPyBeginAllowThreads();
3307 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3308
3309 wxPyEndAllowThreads(__tstate);
3310 if (PyErr_Occurred()) SWIG_fail;
3311 }
3312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3313 return resultobj;
3314 fail:
3315 return NULL;
3316 }
3317
3318
3319 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3320 PyObject *obj;
3321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3322 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3323 Py_INCREF(obj);
3324 return Py_BuildValue((char *)"");
3325 }
3326 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
3329 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
3330 wxGridCellDateTimeRenderer *result;
3331 PyObject * obj0 = 0 ;
3332 PyObject * obj1 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "outformat",(char *) "informat", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3338 if (obj0) {
3339 {
3340 wxString* sptr = wxString_in_helper(obj0);
3341 if (sptr == NULL) SWIG_fail;
3342 arg1 = *sptr;
3343 delete sptr;
3344 }
3345 }
3346 if (obj1) {
3347 {
3348 wxString* sptr = wxString_in_helper(obj1);
3349 if (sptr == NULL) SWIG_fail;
3350 arg2 = *sptr;
3351 delete sptr;
3352 }
3353 }
3354 {
3355 PyThreadState* __tstate = wxPyBeginAllowThreads();
3356 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3357
3358 wxPyEndAllowThreads(__tstate);
3359 if (PyErr_Occurred()) SWIG_fail;
3360 }
3361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3369 PyObject *obj;
3370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3371 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3372 Py_INCREF(obj);
3373 return Py_BuildValue((char *)"");
3374 }
3375 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3376 PyObject *resultobj;
3377 wxString const &arg1_defvalue = wxPyEmptyString ;
3378 wxString *arg1 = (wxString *) &arg1_defvalue ;
3379 wxGridCellEnumRenderer *result;
3380 bool temp1 = false ;
3381 PyObject * obj0 = 0 ;
3382 char *kwnames[] = {
3383 (char *) "choices", NULL
3384 };
3385
3386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3387 if (obj0) {
3388 {
3389 arg1 = wxString_in_helper(obj0);
3390 if (arg1 == NULL) SWIG_fail;
3391 temp1 = true;
3392 }
3393 }
3394 {
3395 PyThreadState* __tstate = wxPyBeginAllowThreads();
3396 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3397
3398 wxPyEndAllowThreads(__tstate);
3399 if (PyErr_Occurred()) SWIG_fail;
3400 }
3401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3402 {
3403 if (temp1)
3404 delete arg1;
3405 }
3406 return resultobj;
3407 fail:
3408 {
3409 if (temp1)
3410 delete arg1;
3411 }
3412 return NULL;
3413 }
3414
3415
3416 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3417 PyObject *obj;
3418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3419 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3420 Py_INCREF(obj);
3421 return Py_BuildValue((char *)"");
3422 }
3423 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3424 PyObject *resultobj;
3425 wxGridCellAutoWrapStringRenderer *result;
3426 char *kwnames[] = {
3427 NULL
3428 };
3429
3430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3439 return resultobj;
3440 fail:
3441 return NULL;
3442 }
3443
3444
3445 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3446 PyObject *obj;
3447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3448 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3449 Py_INCREF(obj);
3450 return Py_BuildValue((char *)"");
3451 }
3452 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3453 PyObject *resultobj;
3454 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3455 PyObject *arg2 = (PyObject *) 0 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "_self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 arg2 = obj1;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 wxGridCellEditor__setOORInfo(arg1,arg2);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3483 bool result;
3484 PyObject * obj0 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 PyThreadState* __tstate = wxPyBeginAllowThreads();
3494 result = (bool)(arg1)->IsCreated();
3495
3496 wxPyEndAllowThreads(__tstate);
3497 if (PyErr_Occurred()) SWIG_fail;
3498 }
3499 {
3500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3501 }
3502 return resultobj;
3503 fail:
3504 return NULL;
3505 }
3506
3507
3508 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3509 PyObject *resultobj;
3510 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3511 wxControl *result;
3512 PyObject * obj0 = 0 ;
3513 char *kwnames[] = {
3514 (char *) "self", NULL
3515 };
3516
3517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3519 if (SWIG_arg_fail(1)) SWIG_fail;
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (wxControl *)(arg1)->GetControl();
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = wxPyMake_wxObject(result, 0);
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3539 wxControl *arg2 = (wxControl *) 0 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "control", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(2)) SWIG_fail;
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 (arg1)->SetControl(arg2);
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 Py_INCREF(Py_None); resultobj = Py_None;
3559 return resultobj;
3560 fail:
3561 return NULL;
3562 }
3563
3564
3565 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3566 PyObject *resultobj;
3567 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3568 wxGridCellAttr *result;
3569 PyObject * obj0 = 0 ;
3570 char *kwnames[] = {
3571 (char *) "self", NULL
3572 };
3573
3574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3576 if (SWIG_arg_fail(1)) SWIG_fail;
3577 {
3578 PyThreadState* __tstate = wxPyBeginAllowThreads();
3579 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3580
3581 wxPyEndAllowThreads(__tstate);
3582 if (PyErr_Occurred()) SWIG_fail;
3583 }
3584 {
3585 resultobj = wxPyMake_wxGridCellAttr(result, 0);
3586 }
3587 return resultobj;
3588 fail:
3589 return NULL;
3590 }
3591
3592
3593 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3594 PyObject *resultobj;
3595 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3596 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3597 PyObject * obj0 = 0 ;
3598 PyObject * obj1 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "self",(char *) "attr", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(1)) SWIG_fail;
3606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(2)) SWIG_fail;
3608 {
3609 PyThreadState* __tstate = wxPyBeginAllowThreads();
3610 (arg1)->SetCellAttr(arg2);
3611
3612 wxPyEndAllowThreads(__tstate);
3613 if (PyErr_Occurred()) SWIG_fail;
3614 }
3615 Py_INCREF(Py_None); resultobj = Py_None;
3616 return resultobj;
3617 fail:
3618 return NULL;
3619 }
3620
3621
3622 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3623 PyObject *resultobj;
3624 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3625 wxString *arg2 = 0 ;
3626 bool temp2 = false ;
3627 PyObject * obj0 = 0 ;
3628 PyObject * obj1 = 0 ;
3629 char *kwnames[] = {
3630 (char *) "self",(char *) "params", NULL
3631 };
3632
3633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3635 if (SWIG_arg_fail(1)) SWIG_fail;
3636 {
3637 arg2 = wxString_in_helper(obj1);
3638 if (arg2 == NULL) SWIG_fail;
3639 temp2 = true;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 (arg1)->SetParameters((wxString const &)*arg2);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 Py_INCREF(Py_None); resultobj = Py_None;
3649 {
3650 if (temp2)
3651 delete arg2;
3652 }
3653 return resultobj;
3654 fail:
3655 {
3656 if (temp2)
3657 delete arg2;
3658 }
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3666 PyObject * obj0 = 0 ;
3667 char *kwnames[] = {
3668 (char *) "self", NULL
3669 };
3670
3671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 (arg1)->IncRef();
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3691 PyObject * obj0 = 0 ;
3692 char *kwnames[] = {
3693 (char *) "self", NULL
3694 };
3695
3696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3698 if (SWIG_arg_fail(1)) SWIG_fail;
3699 {
3700 PyThreadState* __tstate = wxPyBeginAllowThreads();
3701 (arg1)->DecRef();
3702
3703 wxPyEndAllowThreads(__tstate);
3704 if (PyErr_Occurred()) SWIG_fail;
3705 }
3706 Py_INCREF(Py_None); resultobj = Py_None;
3707 return resultobj;
3708 fail:
3709 return NULL;
3710 }
3711
3712
3713 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3714 PyObject *resultobj;
3715 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3716 wxWindow *arg2 = (wxWindow *) 0 ;
3717 int arg3 ;
3718 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3719 PyObject * obj0 = 0 ;
3720 PyObject * obj1 = 0 ;
3721 PyObject * obj2 = 0 ;
3722 PyObject * obj3 = 0 ;
3723 char *kwnames[] = {
3724 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3725 };
3726
3727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3729 if (SWIG_arg_fail(1)) SWIG_fail;
3730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3731 if (SWIG_arg_fail(2)) SWIG_fail;
3732 {
3733 arg3 = (int)(SWIG_As_int(obj2));
3734 if (SWIG_arg_fail(3)) SWIG_fail;
3735 }
3736 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(4)) SWIG_fail;
3738 {
3739 PyThreadState* __tstate = wxPyBeginAllowThreads();
3740 (arg1)->Create(arg2,arg3,arg4);
3741
3742 wxPyEndAllowThreads(__tstate);
3743 if (PyErr_Occurred()) SWIG_fail;
3744 }
3745 Py_INCREF(Py_None); resultobj = Py_None;
3746 return resultobj;
3747 fail:
3748 return NULL;
3749 }
3750
3751
3752 static PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3753 PyObject *resultobj;
3754 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3755 int arg2 ;
3756 int arg3 ;
3757 wxGrid *arg4 = (wxGrid *) 0 ;
3758 PyObject * obj0 = 0 ;
3759 PyObject * obj1 = 0 ;
3760 PyObject * obj2 = 0 ;
3761 PyObject * obj3 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 arg3 = (int)(SWIG_As_int(obj2));
3775 if (SWIG_arg_fail(3)) SWIG_fail;
3776 }
3777 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3778 if (SWIG_arg_fail(4)) SWIG_fail;
3779 {
3780 PyThreadState* __tstate = wxPyBeginAllowThreads();
3781 (arg1)->BeginEdit(arg2,arg3,arg4);
3782
3783 wxPyEndAllowThreads(__tstate);
3784 if (PyErr_Occurred()) SWIG_fail;
3785 }
3786 Py_INCREF(Py_None); resultobj = Py_None;
3787 return resultobj;
3788 fail:
3789 return NULL;
3790 }
3791
3792
3793 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3794 PyObject *resultobj;
3795 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3796 int arg2 ;
3797 int arg3 ;
3798 wxGrid *arg4 = (wxGrid *) 0 ;
3799 bool result;
3800 PyObject * obj0 = 0 ;
3801 PyObject * obj1 = 0 ;
3802 PyObject * obj2 = 0 ;
3803 PyObject * obj3 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3810 if (SWIG_arg_fail(1)) SWIG_fail;
3811 {
3812 arg2 = (int)(SWIG_As_int(obj1));
3813 if (SWIG_arg_fail(2)) SWIG_fail;
3814 }
3815 {
3816 arg3 = (int)(SWIG_As_int(obj2));
3817 if (SWIG_arg_fail(3)) SWIG_fail;
3818 }
3819 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(4)) SWIG_fail;
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3840 PyObject * obj0 = 0 ;
3841 char *kwnames[] = {
3842 (char *) "self", NULL
3843 };
3844
3845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
3846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3847 if (SWIG_arg_fail(1)) SWIG_fail;
3848 {
3849 PyThreadState* __tstate = wxPyBeginAllowThreads();
3850 (arg1)->Reset();
3851
3852 wxPyEndAllowThreads(__tstate);
3853 if (PyErr_Occurred()) SWIG_fail;
3854 }
3855 Py_INCREF(Py_None); resultobj = Py_None;
3856 return resultobj;
3857 fail:
3858 return NULL;
3859 }
3860
3861
3862 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3863 PyObject *resultobj;
3864 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3865 wxGridCellEditor *result;
3866 PyObject * obj0 = 0 ;
3867 char *kwnames[] = {
3868 (char *) "self", NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
3872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3873 if (SWIG_arg_fail(1)) SWIG_fail;
3874 {
3875 PyThreadState* __tstate = wxPyBeginAllowThreads();
3876 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
3877
3878 wxPyEndAllowThreads(__tstate);
3879 if (PyErr_Occurred()) SWIG_fail;
3880 }
3881 {
3882 resultobj = wxPyMake_wxGridCellEditor(result, 0);
3883 }
3884 return resultobj;
3885 fail:
3886 return NULL;
3887 }
3888
3889
3890 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
3891 PyObject *resultobj;
3892 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3893 wxRect *arg2 = 0 ;
3894 wxRect temp2 ;
3895 PyObject * obj0 = 0 ;
3896 PyObject * obj1 = 0 ;
3897 char *kwnames[] = {
3898 (char *) "self",(char *) "rect", NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
3902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3903 if (SWIG_arg_fail(1)) SWIG_fail;
3904 {
3905 arg2 = &temp2;
3906 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3907 }
3908 {
3909 PyThreadState* __tstate = wxPyBeginAllowThreads();
3910 (arg1)->SetSize((wxRect const &)*arg2);
3911
3912 wxPyEndAllowThreads(__tstate);
3913 if (PyErr_Occurred()) SWIG_fail;
3914 }
3915 Py_INCREF(Py_None); resultobj = Py_None;
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3925 bool arg2 ;
3926 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
3927 PyObject * obj0 = 0 ;
3928 PyObject * obj1 = 0 ;
3929 PyObject * obj2 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "self",(char *) "show",(char *) "attr", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
3935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(1)) SWIG_fail;
3937 {
3938 arg2 = (bool)(SWIG_As_bool(obj1));
3939 if (SWIG_arg_fail(2)) SWIG_fail;
3940 }
3941 if (obj2) {
3942 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3943 if (SWIG_arg_fail(3)) SWIG_fail;
3944 }
3945 {
3946 PyThreadState* __tstate = wxPyBeginAllowThreads();
3947 (arg1)->Show(arg2,arg3);
3948
3949 wxPyEndAllowThreads(__tstate);
3950 if (PyErr_Occurred()) SWIG_fail;
3951 }
3952 Py_INCREF(Py_None); resultobj = Py_None;
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3962 wxRect *arg2 = 0 ;
3963 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
3964 wxRect temp2 ;
3965 PyObject * obj0 = 0 ;
3966 PyObject * obj1 = 0 ;
3967 PyObject * obj2 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 arg2 = &temp2;
3977 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3978 }
3979 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3980 if (SWIG_arg_fail(3)) SWIG_fail;
3981 {
3982 PyThreadState* __tstate = wxPyBeginAllowThreads();
3983 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
3984
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3998 wxKeyEvent *arg2 = 0 ;
3999 bool result;
4000 PyObject * obj0 = 0 ;
4001 PyObject * obj1 = 0 ;
4002 char *kwnames[] = {
4003 (char *) "self",(char *) "event", NULL
4004 };
4005
4006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4008 if (SWIG_arg_fail(1)) SWIG_fail;
4009 {
4010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4011 if (SWIG_arg_fail(2)) SWIG_fail;
4012 if (arg2 == NULL) {
4013 SWIG_null_ref("wxKeyEvent");
4014 }
4015 if (SWIG_arg_fail(2)) SWIG_fail;
4016 }
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4020
4021 wxPyEndAllowThreads(__tstate);
4022 if (PyErr_Occurred()) SWIG_fail;
4023 }
4024 {
4025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4026 }
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4036 wxKeyEvent *arg2 = 0 ;
4037 PyObject * obj0 = 0 ;
4038 PyObject * obj1 = 0 ;
4039 char *kwnames[] = {
4040 (char *) "self",(char *) "event", NULL
4041 };
4042
4043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4045 if (SWIG_arg_fail(1)) SWIG_fail;
4046 {
4047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(2)) SWIG_fail;
4049 if (arg2 == NULL) {
4050 SWIG_null_ref("wxKeyEvent");
4051 }
4052 if (SWIG_arg_fail(2)) SWIG_fail;
4053 }
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 (arg1)->StartingKey(*arg2);
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 Py_INCREF(Py_None); resultobj = Py_None;
4062 return resultobj;
4063 fail:
4064 return NULL;
4065 }
4066
4067
4068 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj;
4070 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4071 PyObject * obj0 = 0 ;
4072 char *kwnames[] = {
4073 (char *) "self", NULL
4074 };
4075
4076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4078 if (SWIG_arg_fail(1)) SWIG_fail;
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 (arg1)->StartingClick();
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 Py_INCREF(Py_None); resultobj = Py_None;
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4096 wxKeyEvent *arg2 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 PyObject * obj1 = 0 ;
4099 char *kwnames[] = {
4100 (char *) "self",(char *) "event", NULL
4101 };
4102
4103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4105 if (SWIG_arg_fail(1)) SWIG_fail;
4106 {
4107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(2)) SWIG_fail;
4109 if (arg2 == NULL) {
4110 SWIG_null_ref("wxKeyEvent");
4111 }
4112 if (SWIG_arg_fail(2)) SWIG_fail;
4113 }
4114 {
4115 PyThreadState* __tstate = wxPyBeginAllowThreads();
4116 (arg1)->HandleReturn(*arg2);
4117
4118 wxPyEndAllowThreads(__tstate);
4119 if (PyErr_Occurred()) SWIG_fail;
4120 }
4121 Py_INCREF(Py_None); resultobj = Py_None;
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj;
4130 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4131 PyObject * obj0 = 0 ;
4132 char *kwnames[] = {
4133 (char *) "self", NULL
4134 };
4135
4136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 (arg1)->Destroy();
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 * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4154 PyObject *obj;
4155 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4156 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4157 Py_INCREF(obj);
4158 return Py_BuildValue((char *)"");
4159 }
4160 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 wxPyGridCellEditor *result;
4163 char *kwnames[] = {
4164 NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4176 return resultobj;
4177 fail:
4178 return NULL;
4179 }
4180
4181
4182 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4183 PyObject *resultobj;
4184 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4185 PyObject *arg2 = (PyObject *) 0 ;
4186 PyObject *arg3 = (PyObject *) 0 ;
4187 PyObject * obj0 = 0 ;
4188 PyObject * obj1 = 0 ;
4189 PyObject * obj2 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "self",(char *) "self",(char *) "_class", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 arg2 = obj1;
4198 arg3 = obj2;
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 (arg1)->_setCallbackInfo(arg2,arg3);
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 Py_INCREF(Py_None); resultobj = Py_None;
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_PyGridCellEditor_base_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4216 wxRect *arg2 = 0 ;
4217 wxRect temp2 ;
4218 PyObject * obj0 = 0 ;
4219 PyObject * obj1 = 0 ;
4220 char *kwnames[] = {
4221 (char *) "self",(char *) "rect", NULL
4222 };
4223
4224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetSize",kwnames,&obj0,&obj1)) goto fail;
4225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4226 if (SWIG_arg_fail(1)) SWIG_fail;
4227 {
4228 arg2 = &temp2;
4229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4230 }
4231 {
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 (arg1)->base_SetSize((wxRect const &)*arg2);
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 Py_INCREF(Py_None); resultobj = Py_None;
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_PyGridCellEditor_base_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4248 bool arg2 ;
4249 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4250 PyObject * obj0 = 0 ;
4251 PyObject * obj1 = 0 ;
4252 PyObject * obj2 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self",(char *) "show",(char *) "attr", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_base_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 arg2 = (bool)(SWIG_As_bool(obj1));
4262 if (SWIG_arg_fail(2)) SWIG_fail;
4263 }
4264 if (obj2) {
4265 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4266 if (SWIG_arg_fail(3)) SWIG_fail;
4267 }
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 (arg1)->base_Show(arg2,arg3);
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 Py_INCREF(Py_None); resultobj = Py_None;
4276 return resultobj;
4277 fail:
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_PyGridCellEditor_base_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4285 wxRect *arg2 = 0 ;
4286 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4287 wxRect temp2 ;
4288 PyObject * obj0 = 0 ;
4289 PyObject * obj1 = 0 ;
4290 PyObject * obj2 = 0 ;
4291 char *kwnames[] = {
4292 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_base_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4297 if (SWIG_arg_fail(1)) SWIG_fail;
4298 {
4299 arg2 = &temp2;
4300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4301 }
4302 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4303 if (SWIG_arg_fail(3)) SWIG_fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 (arg1)->base_PaintBackground((wxRect const &)*arg2,arg3);
4307
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 Py_INCREF(Py_None); resultobj = Py_None;
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_PyGridCellEditor_base_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4321 wxKeyEvent *arg2 = 0 ;
4322 bool result;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self",(char *) "event", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 {
4333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4334 if (SWIG_arg_fail(2)) SWIG_fail;
4335 if (arg2 == NULL) {
4336 SWIG_null_ref("wxKeyEvent");
4337 }
4338 if (SWIG_arg_fail(2)) SWIG_fail;
4339 }
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 result = (bool)(arg1)->base_IsAcceptedKey(*arg2);
4343
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 {
4348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4349 }
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_PyGridCellEditor_base_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4359 wxKeyEvent *arg2 = 0 ;
4360 PyObject * obj0 = 0 ;
4361 PyObject * obj1 = 0 ;
4362 char *kwnames[] = {
4363 (char *) "self",(char *) "event", NULL
4364 };
4365
4366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4368 if (SWIG_arg_fail(1)) SWIG_fail;
4369 {
4370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(2)) SWIG_fail;
4372 if (arg2 == NULL) {
4373 SWIG_null_ref("wxKeyEvent");
4374 }
4375 if (SWIG_arg_fail(2)) SWIG_fail;
4376 }
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
4379 (arg1)->base_StartingKey(*arg2);
4380
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 Py_INCREF(Py_None); resultobj = Py_None;
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_PyGridCellEditor_base_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4394 PyObject * obj0 = 0 ;
4395 char *kwnames[] = {
4396 (char *) "self", NULL
4397 };
4398
4399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_StartingClick",kwnames,&obj0)) goto fail;
4400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4401 if (SWIG_arg_fail(1)) SWIG_fail;
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 (arg1)->base_StartingClick();
4405
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 Py_INCREF(Py_None); resultobj = Py_None;
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 static PyObject *_wrap_PyGridCellEditor_base_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4417 PyObject *resultobj;
4418 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4419 wxKeyEvent *arg2 = 0 ;
4420 PyObject * obj0 = 0 ;
4421 PyObject * obj1 = 0 ;
4422 char *kwnames[] = {
4423 (char *) "self",(char *) "event", NULL
4424 };
4425
4426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4428 if (SWIG_arg_fail(1)) SWIG_fail;
4429 {
4430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(2)) SWIG_fail;
4432 if (arg2 == NULL) {
4433 SWIG_null_ref("wxKeyEvent");
4434 }
4435 if (SWIG_arg_fail(2)) SWIG_fail;
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 (arg1)->base_HandleReturn(*arg2);
4440
4441 wxPyEndAllowThreads(__tstate);
4442 if (PyErr_Occurred()) SWIG_fail;
4443 }
4444 Py_INCREF(Py_None); resultobj = Py_None;
4445 return resultobj;
4446 fail:
4447 return NULL;
4448 }
4449
4450
4451 static PyObject *_wrap_PyGridCellEditor_base_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4452 PyObject *resultobj;
4453 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4454 PyObject * obj0 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "self", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_Destroy",kwnames,&obj0)) goto fail;
4460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(1)) SWIG_fail;
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 (arg1)->base_Destroy();
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_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4477 PyObject *resultobj;
4478 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4479 wxString *arg2 = 0 ;
4480 bool temp2 = false ;
4481 PyObject * obj0 = 0 ;
4482 PyObject * obj1 = 0 ;
4483 char *kwnames[] = {
4484 (char *) "self",(char *) "params", NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetParameters",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 arg2 = wxString_in_helper(obj1);
4492 if (arg2 == NULL) SWIG_fail;
4493 temp2 = true;
4494 }
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 (arg1)->base_SetParameters((wxString const &)*arg2);
4498
4499 wxPyEndAllowThreads(__tstate);
4500 if (PyErr_Occurred()) SWIG_fail;
4501 }
4502 Py_INCREF(Py_None); resultobj = Py_None;
4503 {
4504 if (temp2)
4505 delete arg2;
4506 }
4507 return resultobj;
4508 fail:
4509 {
4510 if (temp2)
4511 delete arg2;
4512 }
4513 return NULL;
4514 }
4515
4516
4517 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4518 PyObject *obj;
4519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4520 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4521 Py_INCREF(obj);
4522 return Py_BuildValue((char *)"");
4523 }
4524 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj;
4526 wxGridCellTextEditor *result;
4527 char *kwnames[] = {
4528 NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4535
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj;
4548 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4549 wxString result;
4550 PyObject * obj0 = 0 ;
4551 char *kwnames[] = {
4552 (char *) "self", NULL
4553 };
4554
4555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4557 if (SWIG_arg_fail(1)) SWIG_fail;
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (arg1)->GetValue();
4561
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 {
4566 #if wxUSE_UNICODE
4567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4568 #else
4569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4570 #endif
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4579 PyObject *obj;
4580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4581 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4582 Py_INCREF(obj);
4583 return Py_BuildValue((char *)"");
4584 }
4585 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj;
4587 int arg1 = (int) -1 ;
4588 int arg2 = (int) -1 ;
4589 wxGridCellNumberEditor *result;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 char *kwnames[] = {
4593 (char *) "min",(char *) "max", NULL
4594 };
4595
4596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4597 if (obj0) {
4598 {
4599 arg1 = (int)(SWIG_As_int(obj0));
4600 if (SWIG_arg_fail(1)) SWIG_fail;
4601 }
4602 }
4603 if (obj1) {
4604 {
4605 arg2 = (int)(SWIG_As_int(obj1));
4606 if (SWIG_arg_fail(2)) SWIG_fail;
4607 }
4608 }
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj;
4625 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4626 wxString result;
4627 PyObject * obj0 = 0 ;
4628 char *kwnames[] = {
4629 (char *) "self", NULL
4630 };
4631
4632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4634 if (SWIG_arg_fail(1)) SWIG_fail;
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 result = (arg1)->GetValue();
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 #if wxUSE_UNICODE
4644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4645 #else
4646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4647 #endif
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4656 PyObject *obj;
4657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4658 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4659 Py_INCREF(obj);
4660 return Py_BuildValue((char *)"");
4661 }
4662 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 int arg1 = (int) -1 ;
4665 int arg2 = (int) -1 ;
4666 wxGridCellFloatEditor *result;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "width",(char *) "precision", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4674 if (obj0) {
4675 {
4676 arg1 = (int)(SWIG_As_int(obj0));
4677 if (SWIG_arg_fail(1)) SWIG_fail;
4678 }
4679 }
4680 if (obj1) {
4681 {
4682 arg2 = (int)(SWIG_As_int(obj1));
4683 if (SWIG_arg_fail(2)) SWIG_fail;
4684 }
4685 }
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4689
4690 wxPyEndAllowThreads(__tstate);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj;
4702 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4703 wxString result;
4704 PyObject * obj0 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (arg1)->GetValue();
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 {
4720 #if wxUSE_UNICODE
4721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4722 #else
4723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4724 #endif
4725 }
4726 return resultobj;
4727 fail:
4728 return NULL;
4729 }
4730
4731
4732 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4733 PyObject *obj;
4734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4735 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4736 Py_INCREF(obj);
4737 return Py_BuildValue((char *)"");
4738 }
4739 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4740 PyObject *resultobj;
4741 wxGridCellBoolEditor *result;
4742 char *kwnames[] = {
4743 NULL
4744 };
4745
4746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4750
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj;
4763 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4764 wxString result;
4765 PyObject * obj0 = 0 ;
4766 char *kwnames[] = {
4767 (char *) "self", NULL
4768 };
4769
4770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4772 if (SWIG_arg_fail(1)) SWIG_fail;
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (arg1)->GetValue();
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 {
4781 #if wxUSE_UNICODE
4782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4783 #else
4784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4785 #endif
4786 }
4787 return resultobj;
4788 fail:
4789 return NULL;
4790 }
4791
4792
4793 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
4794 PyObject *obj;
4795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4796 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
4797 Py_INCREF(obj);
4798 return Py_BuildValue((char *)"");
4799 }
4800 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj;
4802 int arg1 = (int) 0 ;
4803 wxString *arg2 = (wxString *) NULL ;
4804 bool arg3 = (bool) false ;
4805 wxGridCellChoiceEditor *result;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char *kwnames[] = {
4809 (char *) "choices",(char *) "allowOthers", NULL
4810 };
4811
4812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
4813 if (obj0) {
4814 {
4815 arg1 = PyList_Size(obj0);
4816 arg2 = wxString_LIST_helper(obj0);
4817 if (arg2 == NULL) SWIG_fail;
4818 }
4819 }
4820 if (obj1) {
4821 {
4822 arg3 = (bool)(SWIG_As_bool(obj1));
4823 if (SWIG_arg_fail(3)) SWIG_fail;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
4829
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
4834 {
4835 if (arg2) delete [] arg2;
4836 }
4837 return resultobj;
4838 fail:
4839 {
4840 if (arg2) delete [] arg2;
4841 }
4842 return NULL;
4843 }
4844
4845
4846 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj;
4848 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
4849 wxString result;
4850 PyObject * obj0 = 0 ;
4851 char *kwnames[] = {
4852 (char *) "self", NULL
4853 };
4854
4855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
4856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
4857 if (SWIG_arg_fail(1)) SWIG_fail;
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 result = (arg1)->GetValue();
4861
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 {
4866 #if wxUSE_UNICODE
4867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4868 #else
4869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4870 #endif
4871 }
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
4879 PyObject *obj;
4880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4881 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
4882 Py_INCREF(obj);
4883 return Py_BuildValue((char *)"");
4884 }
4885 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj;
4887 wxString const &arg1_defvalue = wxPyEmptyString ;
4888 wxString *arg1 = (wxString *) &arg1_defvalue ;
4889 wxGridCellEnumEditor *result;
4890 bool temp1 = false ;
4891 PyObject * obj0 = 0 ;
4892 char *kwnames[] = {
4893 (char *) "choices", NULL
4894 };
4895
4896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
4897 if (obj0) {
4898 {
4899 arg1 = wxString_in_helper(obj0);
4900 if (arg1 == NULL) SWIG_fail;
4901 temp1 = true;
4902 }
4903 }
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
4907
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
4912 {
4913 if (temp1)
4914 delete arg1;
4915 }
4916 return resultobj;
4917 fail:
4918 {
4919 if (temp1)
4920 delete arg1;
4921 }
4922 return NULL;
4923 }
4924
4925
4926 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4927 PyObject *resultobj;
4928 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
4929 wxString result;
4930 PyObject * obj0 = 0 ;
4931 char *kwnames[] = {
4932 (char *) "self", NULL
4933 };
4934
4935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
4936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
4937 if (SWIG_arg_fail(1)) SWIG_fail;
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (arg1)->GetValue();
4941
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 {
4946 #if wxUSE_UNICODE
4947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4948 #else
4949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4950 #endif
4951 }
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
4958 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
4959 PyObject *obj;
4960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4961 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
4962 Py_INCREF(obj);
4963 return Py_BuildValue((char *)"");
4964 }
4965 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxGridCellAutoWrapStringEditor *result;
4968 char *kwnames[] = {
4969 NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
4976
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
4990 wxString result;
4991 PyObject * obj0 = 0 ;
4992 char *kwnames[] = {
4993 (char *) "self", NULL
4994 };
4995
4996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
4997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
4998 if (SWIG_arg_fail(1)) SWIG_fail;
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 result = (arg1)->GetValue();
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 {
5007 #if wxUSE_UNICODE
5008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5009 #else
5010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5011 #endif
5012 }
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5020 PyObject *obj;
5021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5022 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5023 Py_INCREF(obj);
5024 return Py_BuildValue((char *)"");
5025 }
5026 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5029 PyObject *arg2 = (PyObject *) 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 char *kwnames[] = {
5033 (char *) "self",(char *) "_self", NULL
5034 };
5035
5036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5038 if (SWIG_arg_fail(1)) SWIG_fail;
5039 arg2 = obj1;
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 wxGridCellAttr__setOORInfo(arg1,arg2);
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 Py_INCREF(Py_None); resultobj = Py_None;
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5057 wxGridCellAttr *result;
5058 PyObject * obj0 = 0 ;
5059 char *kwnames[] = {
5060 (char *) "attrDefault", NULL
5061 };
5062
5063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5064 if (obj0) {
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 resultobj = wxPyMake_wxGridCellAttr(result, 1);
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5087 wxGridCellAttr *result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 resultobj = wxPyMake_wxGridCellAttr(result, 0);
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj;
5114 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5115 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 char *kwnames[] = {
5119 (char *) "self",(char *) "mergefrom", NULL
5120 };
5121
5122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5124 if (SWIG_arg_fail(1)) SWIG_fail;
5125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(2)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->MergeWith(arg2);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 Py_INCREF(Py_None); resultobj = Py_None;
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
5143 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5144 PyObject * obj0 = 0 ;
5145 char *kwnames[] = {
5146 (char *) "self", NULL
5147 };
5148
5149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5151 if (SWIG_arg_fail(1)) SWIG_fail;
5152 {
5153 PyThreadState* __tstate = wxPyBeginAllowThreads();
5154 (arg1)->IncRef();
5155
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 Py_INCREF(Py_None); resultobj = Py_None;
5160 return resultobj;
5161 fail:
5162 return NULL;
5163 }
5164
5165
5166 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5167 PyObject *resultobj;
5168 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5169 PyObject * obj0 = 0 ;
5170 char *kwnames[] = {
5171 (char *) "self", NULL
5172 };
5173
5174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5176 if (SWIG_arg_fail(1)) SWIG_fail;
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 (arg1)->DecRef();
5180
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 Py_INCREF(Py_None); resultobj = Py_None;
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj;
5193 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5194 wxColour *arg2 = 0 ;
5195 wxColour temp2 ;
5196 PyObject * obj0 = 0 ;
5197 PyObject * obj1 = 0 ;
5198 char *kwnames[] = {
5199 (char *) "self",(char *) "colText", NULL
5200 };
5201
5202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5204 if (SWIG_arg_fail(1)) SWIG_fail;
5205 {
5206 arg2 = &temp2;
5207 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5208 }
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 (arg1)->SetTextColour((wxColour const &)*arg2);
5212
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 Py_INCREF(Py_None); resultobj = Py_None;
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj;
5225 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5226 wxColour *arg2 = 0 ;
5227 wxColour temp2 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char *kwnames[] = {
5231 (char *) "self",(char *) "colBack", NULL
5232 };
5233
5234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5236 if (SWIG_arg_fail(1)) SWIG_fail;
5237 {
5238 arg2 = &temp2;
5239 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5240 }
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5244
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 Py_INCREF(Py_None); resultobj = Py_None;
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 static PyObject *_wrap_GridCellAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj;
5257 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5258 wxFont *arg2 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 PyObject * obj1 = 0 ;
5261 char *kwnames[] = {
5262 (char *) "self",(char *) "font", NULL
5263 };
5264
5265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5267 if (SWIG_arg_fail(1)) SWIG_fail;
5268 {
5269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5270 if (SWIG_arg_fail(2)) SWIG_fail;
5271 if (arg2 == NULL) {
5272 SWIG_null_ref("wxFont");
5273 }
5274 if (SWIG_arg_fail(2)) SWIG_fail;
5275 }
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 (arg1)->SetFont((wxFont const &)*arg2);
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 Py_INCREF(Py_None); resultobj = Py_None;
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5291 PyObject *resultobj;
5292 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5293 int arg2 ;
5294 int arg3 ;
5295 PyObject * obj0 = 0 ;
5296 PyObject * obj1 = 0 ;
5297 PyObject * obj2 = 0 ;
5298 char *kwnames[] = {
5299 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5300 };
5301
5302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5304 if (SWIG_arg_fail(1)) SWIG_fail;
5305 {
5306 arg2 = (int)(SWIG_As_int(obj1));
5307 if (SWIG_arg_fail(2)) SWIG_fail;
5308 }
5309 {
5310 arg3 = (int)(SWIG_As_int(obj2));
5311 if (SWIG_arg_fail(3)) SWIG_fail;
5312 }
5313 {
5314 PyThreadState* __tstate = wxPyBeginAllowThreads();
5315 (arg1)->SetAlignment(arg2,arg3);
5316
5317 wxPyEndAllowThreads(__tstate);
5318 if (PyErr_Occurred()) SWIG_fail;
5319 }
5320 Py_INCREF(Py_None); resultobj = Py_None;
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5328 PyObject *resultobj;
5329 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5330 int arg2 ;
5331 int arg3 ;
5332 PyObject * obj0 = 0 ;
5333 PyObject * obj1 = 0 ;
5334 PyObject * obj2 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 arg2 = (int)(SWIG_As_int(obj1));
5344 if (SWIG_arg_fail(2)) SWIG_fail;
5345 }
5346 {
5347 arg3 = (int)(SWIG_As_int(obj2));
5348 if (SWIG_arg_fail(3)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetSize(arg2,arg3);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5367 bool arg2 = (bool) true ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "allow", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 if (obj1) {
5378 {
5379 arg2 = (bool)(SWIG_As_bool(obj1));
5380 if (SWIG_arg_fail(2)) SWIG_fail;
5381 }
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetOverflow(arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5400 bool arg2 = (bool) true ;
5401 PyObject * obj0 = 0 ;
5402 PyObject * obj1 = 0 ;
5403 char *kwnames[] = {
5404 (char *) "self",(char *) "isReadOnly", NULL
5405 };
5406
5407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5409 if (SWIG_arg_fail(1)) SWIG_fail;
5410 if (obj1) {
5411 {
5412 arg2 = (bool)(SWIG_As_bool(obj1));
5413 if (SWIG_arg_fail(2)) SWIG_fail;
5414 }
5415 }
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 (arg1)->SetReadOnly(arg2);
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 Py_INCREF(Py_None); resultobj = Py_None;
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5431 PyObject *resultobj;
5432 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5433 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5434 PyObject * obj0 = 0 ;
5435 PyObject * obj1 = 0 ;
5436 char *kwnames[] = {
5437 (char *) "self",(char *) "renderer", NULL
5438 };
5439
5440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5442 if (SWIG_arg_fail(1)) SWIG_fail;
5443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5444 if (SWIG_arg_fail(2)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->SetRenderer(arg2);
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 Py_INCREF(Py_None); resultobj = Py_None;
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5462 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char *kwnames[] = {
5466 (char *) "self",(char *) "editor", NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5471 if (SWIG_arg_fail(1)) SWIG_fail;
5472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(2)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 (arg1)->SetEditor(arg2);
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 Py_INCREF(Py_None); resultobj = Py_None;
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj;
5490 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5491 wxGridCellAttr::wxAttrKind arg2 ;
5492 PyObject * obj0 = 0 ;
5493 PyObject * obj1 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self",(char *) "kind", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 arg2 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj1));
5503 if (SWIG_arg_fail(2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 (arg1)->SetKind((wxGridCellAttr::wxAttrKind )arg2);
5508
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 Py_INCREF(Py_None); resultobj = Py_None;
5513 return resultobj;
5514 fail:
5515 return NULL;
5516 }
5517
5518
5519 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5520 PyObject *resultobj;
5521 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5522 bool result;
5523 PyObject * obj0 = 0 ;
5524 char *kwnames[] = {
5525 (char *) "self", NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5530 if (SWIG_arg_fail(1)) SWIG_fail;
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 {
5539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5540 }
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj;
5549 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5550 bool result;
5551 PyObject * obj0 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5562
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 {
5567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5568 }
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj;
5577 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5578 bool result;
5579 PyObject * obj0 = 0 ;
5580 char *kwnames[] = {
5581 (char *) "self", NULL
5582 };
5583
5584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5586 if (SWIG_arg_fail(1)) SWIG_fail;
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5590
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 {
5595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5596 }
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj;
5605 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5606 bool result;
5607 PyObject * obj0 = 0 ;
5608 char *kwnames[] = {
5609 (char *) "self", NULL
5610 };
5611
5612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5614 if (SWIG_arg_fail(1)) SWIG_fail;
5615 {
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 {
5623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5624 }
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj;
5633 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5634 bool result;
5635 PyObject * obj0 = 0 ;
5636 char *kwnames[] = {
5637 (char *) "self", NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5642 if (SWIG_arg_fail(1)) SWIG_fail;
5643 {
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 {
5651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5652 }
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj;
5661 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5662 bool result;
5663 PyObject * obj0 = 0 ;
5664 char *kwnames[] = {
5665 (char *) "self", NULL
5666 };
5667
5668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5670 if (SWIG_arg_fail(1)) SWIG_fail;
5671 {
5672 PyThreadState* __tstate = wxPyBeginAllowThreads();
5673 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5674
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 {
5679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5680 }
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj;
5689 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5690 bool result;
5691 PyObject * obj0 = 0 ;
5692 char *kwnames[] = {
5693 (char *) "self", NULL
5694 };
5695
5696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5698 if (SWIG_arg_fail(1)) SWIG_fail;
5699 {
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5702
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 {
5707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5708 }
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5718 bool result;
5719 PyObject * obj0 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 {
5735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5736 }
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5746 wxColour result;
5747 PyObject * obj0 = 0 ;
5748 char *kwnames[] = {
5749 (char *) "self", NULL
5750 };
5751
5752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5754 if (SWIG_arg_fail(1)) SWIG_fail;
5755 {
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 {
5763 wxColour * resultptr;
5764 resultptr = new wxColour((wxColour &)(result));
5765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5766 }
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5776 wxColour result;
5777 PyObject * obj0 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "self", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
5783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5784 if (SWIG_arg_fail(1)) SWIG_fail;
5785 {
5786 PyThreadState* __tstate = wxPyBeginAllowThreads();
5787 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
5788
5789 wxPyEndAllowThreads(__tstate);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 {
5793 wxColour * resultptr;
5794 resultptr = new wxColour((wxColour &)(result));
5795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5796 }
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj;
5805 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5806 wxFont result;
5807 PyObject * obj0 = 0 ;
5808 char *kwnames[] = {
5809 (char *) "self", NULL
5810 };
5811
5812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
5813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5814 if (SWIG_arg_fail(1)) SWIG_fail;
5815 {
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = ((wxGridCellAttr const *)arg1)->GetFont();
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 wxFont * resultptr;
5824 resultptr = new wxFont((wxFont &)(result));
5825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5836 int *arg2 = (int *) 0 ;
5837 int *arg3 = (int *) 0 ;
5838 int temp2 ;
5839 int res2 = 0 ;
5840 int temp3 ;
5841 int res3 = 0 ;
5842 PyObject * obj0 = 0 ;
5843 char *kwnames[] = {
5844 (char *) "self", NULL
5845 };
5846
5847 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5848 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
5855
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 Py_INCREF(Py_None); resultobj = Py_None;
5860 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5861 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5862 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5863 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj;
5872 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5873 int *arg2 = (int *) 0 ;
5874 int *arg3 = (int *) 0 ;
5875 int temp2 ;
5876 int res2 = 0 ;
5877 int temp3 ;
5878 int res3 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 char *kwnames[] = {
5881 (char *) "self", NULL
5882 };
5883
5884 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5885 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
5892
5893 wxPyEndAllowThreads(__tstate);
5894 if (PyErr_Occurred()) SWIG_fail;
5895 }
5896 Py_INCREF(Py_None); resultobj = Py_None;
5897 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5898 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5899 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5900 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj;
5909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5910 bool result;
5911 PyObject * obj0 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "self", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
5917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5918 if (SWIG_arg_fail(1)) SWIG_fail;
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5928 }
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5938 wxGrid *arg2 = (wxGrid *) 0 ;
5939 int arg3 ;
5940 int arg4 ;
5941 wxGridCellRenderer *result;
5942 PyObject * obj0 = 0 ;
5943 PyObject * obj1 = 0 ;
5944 PyObject * obj2 = 0 ;
5945 PyObject * obj3 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(2)) SWIG_fail;
5955 {
5956 arg3 = (int)(SWIG_As_int(obj2));
5957 if (SWIG_arg_fail(3)) SWIG_fail;
5958 }
5959 {
5960 arg4 = (int)(SWIG_As_int(obj3));
5961 if (SWIG_arg_fail(4)) SWIG_fail;
5962 }
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
5966
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj;
5981 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5982 wxGrid *arg2 = (wxGrid *) 0 ;
5983 int arg3 ;
5984 int arg4 ;
5985 wxGridCellEditor *result;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 PyObject * obj2 = 0 ;
5989 PyObject * obj3 = 0 ;
5990 char *kwnames[] = {
5991 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5992 };
5993
5994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5996 if (SWIG_arg_fail(1)) SWIG_fail;
5997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5998 if (SWIG_arg_fail(2)) SWIG_fail;
5999 {
6000 arg3 = (int)(SWIG_As_int(obj2));
6001 if (SWIG_arg_fail(3)) SWIG_fail;
6002 }
6003 {
6004 arg4 = (int)(SWIG_As_int(obj3));
6005 if (SWIG_arg_fail(4)) SWIG_fail;
6006 }
6007 {
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6010
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 {
6015 resultobj = wxPyMake_wxGridCellEditor(result, 0);
6016 }
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6026 bool result;
6027 PyObject * obj0 = 0 ;
6028 char *kwnames[] = {
6029 (char *) "self", NULL
6030 };
6031
6032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6034 if (SWIG_arg_fail(1)) SWIG_fail;
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 {
6043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6044 }
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj;
6053 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6054 wxGridCellAttr::wxAttrKind result;
6055 PyObject * obj0 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "self", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6062 if (SWIG_arg_fail(1)) SWIG_fail;
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6066
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 resultobj = SWIG_From_int((result));
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj;
6079 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6080 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "defAttr", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(2)) SWIG_fail;
6092 {
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 (arg1)->SetDefAttr(arg2);
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 Py_INCREF(Py_None); resultobj = Py_None;
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6107 PyObject *obj;
6108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6109 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6110 Py_INCREF(obj);
6111 return Py_BuildValue((char *)"");
6112 }
6113 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj;
6115 wxGridCellAttrProvider *result;
6116 char *kwnames[] = {
6117 NULL
6118 };
6119
6120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 resultobj = wxPyMake_wxGridCellAttrProvider(result, 1);
6130 }
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj;
6139 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6140 PyObject *arg2 = (PyObject *) 0 ;
6141 PyObject * obj0 = 0 ;
6142 PyObject * obj1 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "self",(char *) "_self", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6149 if (SWIG_arg_fail(1)) SWIG_fail;
6150 arg2 = obj1;
6151 {
6152 PyThreadState* __tstate = wxPyBeginAllowThreads();
6153 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6154
6155 wxPyEndAllowThreads(__tstate);
6156 if (PyErr_Occurred()) SWIG_fail;
6157 }
6158 Py_INCREF(Py_None); resultobj = Py_None;
6159 return resultobj;
6160 fail:
6161 return NULL;
6162 }
6163
6164
6165 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6166 PyObject *resultobj;
6167 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6168 int arg2 ;
6169 int arg3 ;
6170 wxGridCellAttr::wxAttrKind arg4 ;
6171 wxGridCellAttr *result;
6172 PyObject * obj0 = 0 ;
6173 PyObject * obj1 = 0 ;
6174 PyObject * obj2 = 0 ;
6175 PyObject * obj3 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 {
6184 arg2 = (int)(SWIG_As_int(obj1));
6185 if (SWIG_arg_fail(2)) SWIG_fail;
6186 }
6187 {
6188 arg3 = (int)(SWIG_As_int(obj2));
6189 if (SWIG_arg_fail(3)) SWIG_fail;
6190 }
6191 {
6192 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6193 if (SWIG_arg_fail(4)) SWIG_fail;
6194 }
6195 {
6196 PyThreadState* __tstate = wxPyBeginAllowThreads();
6197 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6198
6199 wxPyEndAllowThreads(__tstate);
6200 if (PyErr_Occurred()) SWIG_fail;
6201 }
6202 {
6203 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6204 }
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6214 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6215 int arg3 ;
6216 int arg4 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 PyObject * obj3 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6229 if (SWIG_arg_fail(2)) SWIG_fail;
6230 {
6231 arg3 = (int)(SWIG_As_int(obj2));
6232 if (SWIG_arg_fail(3)) SWIG_fail;
6233 }
6234 {
6235 arg4 = (int)(SWIG_As_int(obj3));
6236 if (SWIG_arg_fail(4)) SWIG_fail;
6237 }
6238 {
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 (arg1)->SetAttr(arg2,arg3,arg4);
6241
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 Py_INCREF(Py_None); resultobj = Py_None;
6246 return resultobj;
6247 fail:
6248 return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6253 PyObject *resultobj;
6254 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6255 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6256 int arg3 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 PyObject * obj2 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self",(char *) "attr",(char *) "row", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6268 if (SWIG_arg_fail(2)) SWIG_fail;
6269 {
6270 arg3 = (int)(SWIG_As_int(obj2));
6271 if (SWIG_arg_fail(3)) SWIG_fail;
6272 }
6273 {
6274 PyThreadState* __tstate = wxPyBeginAllowThreads();
6275 (arg1)->SetRowAttr(arg2,arg3);
6276
6277 wxPyEndAllowThreads(__tstate);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 Py_INCREF(Py_None); resultobj = Py_None;
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj;
6289 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6290 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6291 int arg3 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 PyObject * obj2 = 0 ;
6295 char *kwnames[] = {
6296 (char *) "self",(char *) "attr",(char *) "col", NULL
6297 };
6298
6299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6303 if (SWIG_arg_fail(2)) SWIG_fail;
6304 {
6305 arg3 = (int)(SWIG_As_int(obj2));
6306 if (SWIG_arg_fail(3)) SWIG_fail;
6307 }
6308 {
6309 PyThreadState* __tstate = wxPyBeginAllowThreads();
6310 (arg1)->SetColAttr(arg2,arg3);
6311
6312 wxPyEndAllowThreads(__tstate);
6313 if (PyErr_Occurred()) SWIG_fail;
6314 }
6315 Py_INCREF(Py_None); resultobj = Py_None;
6316 return resultobj;
6317 fail:
6318 return NULL;
6319 }
6320
6321
6322 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj;
6324 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6325 size_t arg2 ;
6326 int arg3 ;
6327 PyObject * obj0 = 0 ;
6328 PyObject * obj1 = 0 ;
6329 PyObject * obj2 = 0 ;
6330 char *kwnames[] = {
6331 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6332 };
6333
6334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6336 if (SWIG_arg_fail(1)) SWIG_fail;
6337 {
6338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6339 if (SWIG_arg_fail(2)) SWIG_fail;
6340 }
6341 {
6342 arg3 = (int)(SWIG_As_int(obj2));
6343 if (SWIG_arg_fail(3)) SWIG_fail;
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 (arg1)->UpdateAttrRows(arg2,arg3);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6362 size_t arg2 ;
6363 int arg3 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 PyObject * obj2 = 0 ;
6367 char *kwnames[] = {
6368 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6369 };
6370
6371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6373 if (SWIG_arg_fail(1)) SWIG_fail;
6374 {
6375 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6376 if (SWIG_arg_fail(2)) SWIG_fail;
6377 }
6378 {
6379 arg3 = (int)(SWIG_As_int(obj2));
6380 if (SWIG_arg_fail(3)) SWIG_fail;
6381 }
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->UpdateAttrCols(arg2,arg3);
6385
6386 wxPyEndAllowThreads(__tstate);
6387 if (PyErr_Occurred()) SWIG_fail;
6388 }
6389 Py_INCREF(Py_None); resultobj = Py_None;
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6397 PyObject *obj;
6398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6399 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6400 Py_INCREF(obj);
6401 return Py_BuildValue((char *)"");
6402 }
6403 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 wxPyGridCellAttrProvider *result;
6406 char *kwnames[] = {
6407 NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6428 PyObject *arg2 = (PyObject *) 0 ;
6429 PyObject *arg3 = (PyObject *) 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 PyObject * obj2 = 0 ;
6433 char *kwnames[] = {
6434 (char *) "self",(char *) "self",(char *) "_class", NULL
6435 };
6436
6437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6439 if (SWIG_arg_fail(1)) SWIG_fail;
6440 arg2 = obj1;
6441 arg3 = obj2;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->_setCallbackInfo(arg2,arg3);
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 Py_INCREF(Py_None); resultobj = Py_None;
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject *_wrap_PyGridCellAttrProvider_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6459 int arg2 ;
6460 int arg3 ;
6461 wxGridCellAttr::wxAttrKind arg4 ;
6462 wxGridCellAttr *result;
6463 PyObject * obj0 = 0 ;
6464 PyObject * obj1 = 0 ;
6465 PyObject * obj2 = 0 ;
6466 PyObject * obj3 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6473 if (SWIG_arg_fail(1)) SWIG_fail;
6474 {
6475 arg2 = (int)(SWIG_As_int(obj1));
6476 if (SWIG_arg_fail(2)) SWIG_fail;
6477 }
6478 {
6479 arg3 = (int)(SWIG_As_int(obj2));
6480 if (SWIG_arg_fail(3)) SWIG_fail;
6481 }
6482 {
6483 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6484 if (SWIG_arg_fail(4)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6489
6490 wxPyEndAllowThreads(__tstate);
6491 if (PyErr_Occurred()) SWIG_fail;
6492 }
6493 {
6494 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6495 }
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_PyGridCellAttrProvider_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6505 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6506 int arg3 ;
6507 int arg4 ;
6508 PyObject * obj0 = 0 ;
6509 PyObject * obj1 = 0 ;
6510 PyObject * obj2 = 0 ;
6511 PyObject * obj3 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(2)) SWIG_fail;
6521 {
6522 arg3 = (int)(SWIG_As_int(obj2));
6523 if (SWIG_arg_fail(3)) SWIG_fail;
6524 }
6525 {
6526 arg4 = (int)(SWIG_As_int(obj3));
6527 if (SWIG_arg_fail(4)) SWIG_fail;
6528 }
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->base_SetAttr(arg2,arg3,arg4);
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 Py_INCREF(Py_None); resultobj = Py_None;
6537 return resultobj;
6538 fail:
6539 return NULL;
6540 }
6541
6542
6543 static PyObject *_wrap_PyGridCellAttrProvider_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj;
6545 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6546 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6547 int arg3 ;
6548 PyObject * obj0 = 0 ;
6549 PyObject * obj1 = 0 ;
6550 PyObject * obj2 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self",(char *) "attr",(char *) "row", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 {
6561 arg3 = (int)(SWIG_As_int(obj2));
6562 if (SWIG_arg_fail(3)) SWIG_fail;
6563 }
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 (arg1)->base_SetRowAttr(arg2,arg3);
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 Py_INCREF(Py_None); resultobj = Py_None;
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 static PyObject *_wrap_PyGridCellAttrProvider_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6579 PyObject *resultobj;
6580 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6581 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6582 int arg3 ;
6583 PyObject * obj0 = 0 ;
6584 PyObject * obj1 = 0 ;
6585 PyObject * obj2 = 0 ;
6586 char *kwnames[] = {
6587 (char *) "self",(char *) "attr",(char *) "col", NULL
6588 };
6589
6590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6592 if (SWIG_arg_fail(1)) SWIG_fail;
6593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6594 if (SWIG_arg_fail(2)) SWIG_fail;
6595 {
6596 arg3 = (int)(SWIG_As_int(obj2));
6597 if (SWIG_arg_fail(3)) SWIG_fail;
6598 }
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 (arg1)->base_SetColAttr(arg2,arg3);
6602
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 Py_INCREF(Py_None); resultobj = Py_None;
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6614 PyObject *obj;
6615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6616 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6617 Py_INCREF(obj);
6618 return Py_BuildValue((char *)"");
6619 }
6620 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6623 PyObject *arg2 = (PyObject *) 0 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self",(char *) "_self", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 arg2 = obj1;
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 wxGridTableBase__setOORInfo(arg1,arg2);
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 Py_INCREF(Py_None); resultobj = Py_None;
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6651 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 char *kwnames[] = {
6655 (char *) "self",(char *) "attrProvider", NULL
6656 };
6657
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(2)) SWIG_fail;
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 (arg1)->SetAttrProvider(arg2);
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 Py_INCREF(Py_None); resultobj = Py_None;
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6680 wxGridCellAttrProvider *result;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 {
6697 resultobj = wxPyMake_wxGridCellAttrProvider(result, 0);
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6708 wxGrid *arg2 = (wxGrid *) 0 ;
6709 PyObject * obj0 = 0 ;
6710 PyObject * obj1 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "grid", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(2)) SWIG_fail;
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->SetView(arg2);
6723
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 Py_INCREF(Py_None); resultobj = Py_None;
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6737 wxGrid *result;
6738 PyObject * obj0 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6749
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 {
6754 resultobj = wxPyMake_wxObject(result, 0);
6755 }
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6763 PyObject *resultobj;
6764 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6765 int result;
6766 PyObject * obj0 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "self", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = (int)(arg1)->GetNumberRows();
6777
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 {
6782 resultobj = SWIG_From_int((int)(result));
6783 }
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6793 int result;
6794 PyObject * obj0 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (int)(arg1)->GetNumberCols();
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 {
6810 resultobj = SWIG_From_int((int)(result));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj;
6820 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6821 int arg2 ;
6822 int arg3 ;
6823 bool result;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 PyObject * obj2 = 0 ;
6827 char *kwnames[] = {
6828 (char *) "self",(char *) "row",(char *) "col", NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
6832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6833 if (SWIG_arg_fail(1)) SWIG_fail;
6834 {
6835 arg2 = (int)(SWIG_As_int(obj1));
6836 if (SWIG_arg_fail(2)) SWIG_fail;
6837 }
6838 {
6839 arg3 = (int)(SWIG_As_int(obj2));
6840 if (SWIG_arg_fail(3)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj;
6860 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6861 int arg2 ;
6862 int arg3 ;
6863 wxString result;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 PyObject * obj2 = 0 ;
6867 char *kwnames[] = {
6868 (char *) "self",(char *) "row",(char *) "col", NULL
6869 };
6870
6871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
6872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6873 if (SWIG_arg_fail(1)) SWIG_fail;
6874 {
6875 arg2 = (int)(SWIG_As_int(obj1));
6876 if (SWIG_arg_fail(2)) SWIG_fail;
6877 }
6878 {
6879 arg3 = (int)(SWIG_As_int(obj2));
6880 if (SWIG_arg_fail(3)) SWIG_fail;
6881 }
6882 {
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 result = (arg1)->GetValue(arg2,arg3);
6885
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 {
6890 #if wxUSE_UNICODE
6891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6892 #else
6893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6894 #endif
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6905 int arg2 ;
6906 int arg3 ;
6907 wxString *arg4 = 0 ;
6908 bool temp4 = false ;
6909 PyObject * obj0 = 0 ;
6910 PyObject * obj1 = 0 ;
6911 PyObject * obj2 = 0 ;
6912 PyObject * obj3 = 0 ;
6913 char *kwnames[] = {
6914 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
6915 };
6916
6917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(1)) SWIG_fail;
6920 {
6921 arg2 = (int)(SWIG_As_int(obj1));
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 arg3 = (int)(SWIG_As_int(obj2));
6926 if (SWIG_arg_fail(3)) SWIG_fail;
6927 }
6928 {
6929 arg4 = wxString_in_helper(obj3);
6930 if (arg4 == NULL) SWIG_fail;
6931 temp4 = true;
6932 }
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 {
6942 if (temp4)
6943 delete arg4;
6944 }
6945 return resultobj;
6946 fail:
6947 {
6948 if (temp4)
6949 delete arg4;
6950 }
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6958 int arg2 ;
6959 int arg3 ;
6960 wxString result;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 PyObject * obj2 = 0 ;
6964 char *kwnames[] = {
6965 (char *) "self",(char *) "row",(char *) "col", NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
6969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6970 if (SWIG_arg_fail(1)) SWIG_fail;
6971 {
6972 arg2 = (int)(SWIG_As_int(obj1));
6973 if (SWIG_arg_fail(2)) SWIG_fail;
6974 }
6975 {
6976 arg3 = (int)(SWIG_As_int(obj2));
6977 if (SWIG_arg_fail(3)) SWIG_fail;
6978 }
6979 {
6980 PyThreadState* __tstate = wxPyBeginAllowThreads();
6981 result = (arg1)->GetTypeName(arg2,arg3);
6982
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 {
6987 #if wxUSE_UNICODE
6988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6989 #else
6990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6991 #endif
6992 }
6993 return resultobj;
6994 fail:
6995 return NULL;
6996 }
6997
6998
6999 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7000 PyObject *resultobj;
7001 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7002 int arg2 ;
7003 int arg3 ;
7004 wxString *arg4 = 0 ;
7005 bool result;
7006 bool temp4 = false ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 PyObject * obj2 = 0 ;
7010 PyObject * obj3 = 0 ;
7011 char *kwnames[] = {
7012 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7013 };
7014
7015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7017 if (SWIG_arg_fail(1)) SWIG_fail;
7018 {
7019 arg2 = (int)(SWIG_As_int(obj1));
7020 if (SWIG_arg_fail(2)) SWIG_fail;
7021 }
7022 {
7023 arg3 = (int)(SWIG_As_int(obj2));
7024 if (SWIG_arg_fail(3)) SWIG_fail;
7025 }
7026 {
7027 arg4 = wxString_in_helper(obj3);
7028 if (arg4 == NULL) SWIG_fail;
7029 temp4 = true;
7030 }
7031 {
7032 PyThreadState* __tstate = wxPyBeginAllowThreads();
7033 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7034
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 {
7039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7040 }
7041 {
7042 if (temp4)
7043 delete arg4;
7044 }
7045 return resultobj;
7046 fail:
7047 {
7048 if (temp4)
7049 delete arg4;
7050 }
7051 return NULL;
7052 }
7053
7054
7055 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj;
7057 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7058 int arg2 ;
7059 int arg3 ;
7060 wxString *arg4 = 0 ;
7061 bool result;
7062 bool temp4 = false ;
7063 PyObject * obj0 = 0 ;
7064 PyObject * obj1 = 0 ;
7065 PyObject * obj2 = 0 ;
7066 PyObject * obj3 = 0 ;
7067 char *kwnames[] = {
7068 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7069 };
7070
7071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7073 if (SWIG_arg_fail(1)) SWIG_fail;
7074 {
7075 arg2 = (int)(SWIG_As_int(obj1));
7076 if (SWIG_arg_fail(2)) SWIG_fail;
7077 }
7078 {
7079 arg3 = (int)(SWIG_As_int(obj2));
7080 if (SWIG_arg_fail(3)) SWIG_fail;
7081 }
7082 {
7083 arg4 = wxString_in_helper(obj3);
7084 if (arg4 == NULL) SWIG_fail;
7085 temp4 = true;
7086 }
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 {
7095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7096 }
7097 {
7098 if (temp4)
7099 delete arg4;
7100 }
7101 return resultobj;
7102 fail:
7103 {
7104 if (temp4)
7105 delete arg4;
7106 }
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj;
7113 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7114 int arg2 ;
7115 int arg3 ;
7116 long result;
7117 PyObject * obj0 = 0 ;
7118 PyObject * obj1 = 0 ;
7119 PyObject * obj2 = 0 ;
7120 char *kwnames[] = {
7121 (char *) "self",(char *) "row",(char *) "col", NULL
7122 };
7123
7124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7126 if (SWIG_arg_fail(1)) SWIG_fail;
7127 {
7128 arg2 = (int)(SWIG_As_int(obj1));
7129 if (SWIG_arg_fail(2)) SWIG_fail;
7130 }
7131 {
7132 arg3 = (int)(SWIG_As_int(obj2));
7133 if (SWIG_arg_fail(3)) SWIG_fail;
7134 }
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7138
7139 wxPyEndAllowThreads(__tstate);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 {
7143 resultobj = SWIG_From_long((long)(result));
7144 }
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7152 PyObject *resultobj;
7153 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7154 int arg2 ;
7155 int arg3 ;
7156 double result;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 PyObject * obj2 = 0 ;
7160 char *kwnames[] = {
7161 (char *) "self",(char *) "row",(char *) "col", NULL
7162 };
7163
7164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7166 if (SWIG_arg_fail(1)) SWIG_fail;
7167 {
7168 arg2 = (int)(SWIG_As_int(obj1));
7169 if (SWIG_arg_fail(2)) SWIG_fail;
7170 }
7171 {
7172 arg3 = (int)(SWIG_As_int(obj2));
7173 if (SWIG_arg_fail(3)) SWIG_fail;
7174 }
7175 {
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7178
7179 wxPyEndAllowThreads(__tstate);
7180 if (PyErr_Occurred()) SWIG_fail;
7181 }
7182 {
7183 resultobj = SWIG_From_double((double)(result));
7184 }
7185 return resultobj;
7186 fail:
7187 return NULL;
7188 }
7189
7190
7191 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7192 PyObject *resultobj;
7193 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7194 int arg2 ;
7195 int arg3 ;
7196 bool result;
7197 PyObject * obj0 = 0 ;
7198 PyObject * obj1 = 0 ;
7199 PyObject * obj2 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self",(char *) "row",(char *) "col", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 {
7208 arg2 = (int)(SWIG_As_int(obj1));
7209 if (SWIG_arg_fail(2)) SWIG_fail;
7210 }
7211 {
7212 arg3 = (int)(SWIG_As_int(obj2));
7213 if (SWIG_arg_fail(3)) SWIG_fail;
7214 }
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7218
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 {
7223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7224 }
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj;
7233 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7234 int arg2 ;
7235 int arg3 ;
7236 long arg4 ;
7237 PyObject * obj0 = 0 ;
7238 PyObject * obj1 = 0 ;
7239 PyObject * obj2 = 0 ;
7240 PyObject * obj3 = 0 ;
7241 char *kwnames[] = {
7242 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7243 };
7244
7245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7247 if (SWIG_arg_fail(1)) SWIG_fail;
7248 {
7249 arg2 = (int)(SWIG_As_int(obj1));
7250 if (SWIG_arg_fail(2)) SWIG_fail;
7251 }
7252 {
7253 arg3 = (int)(SWIG_As_int(obj2));
7254 if (SWIG_arg_fail(3)) SWIG_fail;
7255 }
7256 {
7257 arg4 = (long)(SWIG_As_long(obj3));
7258 if (SWIG_arg_fail(4)) SWIG_fail;
7259 }
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7263
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 Py_INCREF(Py_None); resultobj = Py_None;
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj;
7276 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7277 int arg2 ;
7278 int arg3 ;
7279 double arg4 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 PyObject * obj2 = 0 ;
7283 PyObject * obj3 = 0 ;
7284 char *kwnames[] = {
7285 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7286 };
7287
7288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7290 if (SWIG_arg_fail(1)) SWIG_fail;
7291 {
7292 arg2 = (int)(SWIG_As_int(obj1));
7293 if (SWIG_arg_fail(2)) SWIG_fail;
7294 }
7295 {
7296 arg3 = (int)(SWIG_As_int(obj2));
7297 if (SWIG_arg_fail(3)) SWIG_fail;
7298 }
7299 {
7300 arg4 = (double)(SWIG_As_double(obj3));
7301 if (SWIG_arg_fail(4)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7306
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 Py_INCREF(Py_None); resultobj = Py_None;
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7320 int arg2 ;
7321 int arg3 ;
7322 bool arg4 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 PyObject * obj2 = 0 ;
7326 PyObject * obj3 = 0 ;
7327 char *kwnames[] = {
7328 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7329 };
7330
7331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7333 if (SWIG_arg_fail(1)) SWIG_fail;
7334 {
7335 arg2 = (int)(SWIG_As_int(obj1));
7336 if (SWIG_arg_fail(2)) SWIG_fail;
7337 }
7338 {
7339 arg3 = (int)(SWIG_As_int(obj2));
7340 if (SWIG_arg_fail(3)) SWIG_fail;
7341 }
7342 {
7343 arg4 = (bool)(SWIG_As_bool(obj3));
7344 if (SWIG_arg_fail(4)) SWIG_fail;
7345 }
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7349
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 Py_INCREF(Py_None); resultobj = Py_None;
7354 return resultobj;
7355 fail:
7356 return NULL;
7357 }
7358
7359
7360 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7361 PyObject *resultobj;
7362 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7363 PyObject * obj0 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 PyThreadState* __tstate = wxPyBeginAllowThreads();
7373 (arg1)->Clear();
7374
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 Py_INCREF(Py_None); resultobj = Py_None;
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj;
7387 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7388 size_t arg2 = (size_t) 0 ;
7389 size_t arg3 = (size_t) 1 ;
7390 bool result;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 PyObject * obj2 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 if (obj1) {
7402 {
7403 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7404 if (SWIG_arg_fail(2)) SWIG_fail;
7405 }
7406 }
7407 if (obj2) {
7408 {
7409 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7410 if (SWIG_arg_fail(3)) SWIG_fail;
7411 }
7412 }
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (bool)(arg1)->InsertRows(arg2,arg3);
7416
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 {
7421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7422 }
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7432 size_t arg2 = (size_t) 1 ;
7433 bool result;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char *kwnames[] = {
7437 (char *) "self",(char *) "numRows", NULL
7438 };
7439
7440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7442 if (SWIG_arg_fail(1)) SWIG_fail;
7443 if (obj1) {
7444 {
7445 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->AppendRows(arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7468 size_t arg2 = (size_t) 0 ;
7469 size_t arg3 = (size_t) 1 ;
7470 bool result;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 PyObject * obj2 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 if (obj1) {
7482 {
7483 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7484 if (SWIG_arg_fail(2)) SWIG_fail;
7485 }
7486 }
7487 if (obj2) {
7488 {
7489 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7490 if (SWIG_arg_fail(3)) SWIG_fail;
7491 }
7492 }
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7496
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7502 }
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj;
7511 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7512 size_t arg2 = (size_t) 0 ;
7513 size_t arg3 = (size_t) 1 ;
7514 bool result;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 PyObject * obj2 = 0 ;
7518 char *kwnames[] = {
7519 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7520 };
7521
7522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(1)) SWIG_fail;
7525 if (obj1) {
7526 {
7527 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7528 if (SWIG_arg_fail(2)) SWIG_fail;
7529 }
7530 }
7531 if (obj2) {
7532 {
7533 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7534 if (SWIG_arg_fail(3)) SWIG_fail;
7535 }
7536 }
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 result = (bool)(arg1)->InsertCols(arg2,arg3);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 {
7545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj;
7555 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7556 size_t arg2 = (size_t) 1 ;
7557 bool result;
7558 PyObject * obj0 = 0 ;
7559 PyObject * obj1 = 0 ;
7560 char *kwnames[] = {
7561 (char *) "self",(char *) "numCols", NULL
7562 };
7563
7564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7566 if (SWIG_arg_fail(1)) SWIG_fail;
7567 if (obj1) {
7568 {
7569 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7570 if (SWIG_arg_fail(2)) SWIG_fail;
7571 }
7572 }
7573 {
7574 PyThreadState* __tstate = wxPyBeginAllowThreads();
7575 result = (bool)(arg1)->AppendCols(arg2);
7576
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 {
7581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7592 size_t arg2 = (size_t) 0 ;
7593 size_t arg3 = (size_t) 1 ;
7594 bool result;
7595 PyObject * obj0 = 0 ;
7596 PyObject * obj1 = 0 ;
7597 PyObject * obj2 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 if (obj1) {
7606 {
7607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7608 if (SWIG_arg_fail(2)) SWIG_fail;
7609 }
7610 }
7611 if (obj2) {
7612 {
7613 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7614 if (SWIG_arg_fail(3)) SWIG_fail;
7615 }
7616 }
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7626 }
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7636 int arg2 ;
7637 wxString result;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self",(char *) "row", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 arg2 = (int)(SWIG_As_int(obj1));
7649 if (SWIG_arg_fail(2)) SWIG_fail;
7650 }
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (arg1)->GetRowLabelValue(arg2);
7654
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 {
7659 #if wxUSE_UNICODE
7660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7661 #else
7662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7663 #endif
7664 }
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7674 int arg2 ;
7675 wxString result;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char *kwnames[] = {
7679 (char *) "self",(char *) "col", NULL
7680 };
7681
7682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7684 if (SWIG_arg_fail(1)) SWIG_fail;
7685 {
7686 arg2 = (int)(SWIG_As_int(obj1));
7687 if (SWIG_arg_fail(2)) SWIG_fail;
7688 }
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (arg1)->GetColLabelValue(arg2);
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 #if wxUSE_UNICODE
7698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7699 #else
7700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7701 #endif
7702 }
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj;
7711 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7712 int arg2 ;
7713 wxString *arg3 = 0 ;
7714 bool temp3 = false ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 PyObject * obj2 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self",(char *) "row",(char *) "value", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) 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 {
7726 arg2 = (int)(SWIG_As_int(obj1));
7727 if (SWIG_arg_fail(2)) SWIG_fail;
7728 }
7729 {
7730 arg3 = wxString_in_helper(obj2);
7731 if (arg3 == NULL) SWIG_fail;
7732 temp3 = true;
7733 }
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 Py_INCREF(Py_None); resultobj = Py_None;
7742 {
7743 if (temp3)
7744 delete arg3;
7745 }
7746 return resultobj;
7747 fail:
7748 {
7749 if (temp3)
7750 delete arg3;
7751 }
7752 return NULL;
7753 }
7754
7755
7756 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj;
7758 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7759 int arg2 ;
7760 wxString *arg3 = 0 ;
7761 bool temp3 = false ;
7762 PyObject * obj0 = 0 ;
7763 PyObject * obj1 = 0 ;
7764 PyObject * obj2 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self",(char *) "col",(char *) "value", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 arg2 = (int)(SWIG_As_int(obj1));
7774 if (SWIG_arg_fail(2)) SWIG_fail;
7775 }
7776 {
7777 arg3 = wxString_in_helper(obj2);
7778 if (arg3 == NULL) SWIG_fail;
7779 temp3 = true;
7780 }
7781 {
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
7784
7785 wxPyEndAllowThreads(__tstate);
7786 if (PyErr_Occurred()) SWIG_fail;
7787 }
7788 Py_INCREF(Py_None); resultobj = Py_None;
7789 {
7790 if (temp3)
7791 delete arg3;
7792 }
7793 return resultobj;
7794 fail:
7795 {
7796 if (temp3)
7797 delete arg3;
7798 }
7799 return NULL;
7800 }
7801
7802
7803 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj;
7805 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7806 bool result;
7807 PyObject * obj0 = 0 ;
7808 char *kwnames[] = {
7809 (char *) "self", NULL
7810 };
7811
7812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
7813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7814 if (SWIG_arg_fail(1)) SWIG_fail;
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)(arg1)->CanHaveAttributes();
7818
7819 wxPyEndAllowThreads(__tstate);
7820 if (PyErr_Occurred()) SWIG_fail;
7821 }
7822 {
7823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7824 }
7825 return resultobj;
7826 fail:
7827 return NULL;
7828 }
7829
7830
7831 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7832 PyObject *resultobj;
7833 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7834 int arg2 ;
7835 int arg3 ;
7836 wxGridCellAttr::wxAttrKind arg4 ;
7837 wxGridCellAttr *result;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 PyObject * obj2 = 0 ;
7841 PyObject * obj3 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 arg2 = (int)(SWIG_As_int(obj1));
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 }
7853 {
7854 arg3 = (int)(SWIG_As_int(obj2));
7855 if (SWIG_arg_fail(3)) SWIG_fail;
7856 }
7857 {
7858 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
7859 if (SWIG_arg_fail(4)) SWIG_fail;
7860 }
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
7864
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 {
7869 resultobj = wxPyMake_wxGridCellAttr(result, 0);
7870 }
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj;
7879 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7880 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7881 int arg3 ;
7882 int arg4 ;
7883 PyObject * obj0 = 0 ;
7884 PyObject * obj1 = 0 ;
7885 PyObject * obj2 = 0 ;
7886 PyObject * obj3 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(2)) SWIG_fail;
7896 {
7897 arg3 = (int)(SWIG_As_int(obj2));
7898 if (SWIG_arg_fail(3)) SWIG_fail;
7899 }
7900 {
7901 arg4 = (int)(SWIG_As_int(obj3));
7902 if (SWIG_arg_fail(4)) SWIG_fail;
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 (arg1)->SetAttr(arg2,arg3,arg4);
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 Py_INCREF(Py_None); resultobj = Py_None;
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7919 PyObject *resultobj;
7920 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7921 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7922 int arg3 ;
7923 PyObject * obj0 = 0 ;
7924 PyObject * obj1 = 0 ;
7925 PyObject * obj2 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self",(char *) "attr",(char *) "row", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(2)) SWIG_fail;
7935 {
7936 arg3 = (int)(SWIG_As_int(obj2));
7937 if (SWIG_arg_fail(3)) SWIG_fail;
7938 }
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 (arg1)->SetRowAttr(arg2,arg3);
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 Py_INCREF(Py_None); resultobj = Py_None;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj;
7955 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7956 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7957 int arg3 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 PyObject * obj2 = 0 ;
7961 char *kwnames[] = {
7962 (char *) "self",(char *) "attr",(char *) "col", NULL
7963 };
7964
7965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7967 if (SWIG_arg_fail(1)) SWIG_fail;
7968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 {
7971 arg3 = (int)(SWIG_As_int(obj2));
7972 if (SWIG_arg_fail(3)) SWIG_fail;
7973 }
7974 {
7975 PyThreadState* __tstate = wxPyBeginAllowThreads();
7976 (arg1)->SetColAttr(arg2,arg3);
7977
7978 wxPyEndAllowThreads(__tstate);
7979 if (PyErr_Occurred()) SWIG_fail;
7980 }
7981 Py_INCREF(Py_None); resultobj = Py_None;
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
7989 PyObject *obj;
7990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7991 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
7992 Py_INCREF(obj);
7993 return Py_BuildValue((char *)"");
7994 }
7995 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxPyGridTableBase *result;
7998 char *kwnames[] = {
7999 NULL
8000 };
8001
8002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8020 PyObject *arg2 = (PyObject *) 0 ;
8021 PyObject *arg3 = (PyObject *) 0 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 PyObject * obj2 = 0 ;
8025 char *kwnames[] = {
8026 (char *) "self",(char *) "self",(char *) "_class", NULL
8027 };
8028
8029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 arg2 = obj1;
8033 arg3 = obj2;
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 (arg1)->_setCallbackInfo(arg2,arg3);
8037
8038 wxPyEndAllowThreads(__tstate);
8039 if (PyErr_Occurred()) SWIG_fail;
8040 }
8041 Py_INCREF(Py_None); resultobj = Py_None;
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj;
8050 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8051 PyObject * obj0 = 0 ;
8052 char *kwnames[] = {
8053 (char *) "self", NULL
8054 };
8055
8056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8058 if (SWIG_arg_fail(1)) SWIG_fail;
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 wxPyGridTableBase_Destroy(arg1);
8062
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 Py_INCREF(Py_None); resultobj = Py_None;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 static PyObject *_wrap_PyGridTableBase_base_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj;
8075 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8076 int arg2 ;
8077 int arg3 ;
8078 wxString result;
8079 PyObject * obj0 = 0 ;
8080 PyObject * obj1 = 0 ;
8081 PyObject * obj2 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "self",(char *) "row",(char *) "col", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(1)) SWIG_fail;
8089 {
8090 arg2 = (int)(SWIG_As_int(obj1));
8091 if (SWIG_arg_fail(2)) SWIG_fail;
8092 }
8093 {
8094 arg3 = (int)(SWIG_As_int(obj2));
8095 if (SWIG_arg_fail(3)) SWIG_fail;
8096 }
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (arg1)->base_GetTypeName(arg2,arg3);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 {
8105 #if wxUSE_UNICODE
8106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8107 #else
8108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8109 #endif
8110 }
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 static PyObject *_wrap_PyGridTableBase_base_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj;
8119 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8120 int arg2 ;
8121 int arg3 ;
8122 wxString *arg4 = 0 ;
8123 bool result;
8124 bool temp4 = false ;
8125 PyObject * obj0 = 0 ;
8126 PyObject * obj1 = 0 ;
8127 PyObject * obj2 = 0 ;
8128 PyObject * obj3 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 arg2 = (int)(SWIG_As_int(obj1));
8138 if (SWIG_arg_fail(2)) SWIG_fail;
8139 }
8140 {
8141 arg3 = (int)(SWIG_As_int(obj2));
8142 if (SWIG_arg_fail(3)) SWIG_fail;
8143 }
8144 {
8145 arg4 = wxString_in_helper(obj3);
8146 if (arg4 == NULL) SWIG_fail;
8147 temp4 = true;
8148 }
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (bool)(arg1)->base_CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8158 }
8159 {
8160 if (temp4)
8161 delete arg4;
8162 }
8163 return resultobj;
8164 fail:
8165 {
8166 if (temp4)
8167 delete arg4;
8168 }
8169 return NULL;
8170 }
8171
8172
8173 static PyObject *_wrap_PyGridTableBase_base_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj;
8175 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8176 int arg2 ;
8177 int arg3 ;
8178 wxString *arg4 = 0 ;
8179 bool result;
8180 bool temp4 = false ;
8181 PyObject * obj0 = 0 ;
8182 PyObject * obj1 = 0 ;
8183 PyObject * obj2 = 0 ;
8184 PyObject * obj3 = 0 ;
8185 char *kwnames[] = {
8186 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8187 };
8188
8189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8191 if (SWIG_arg_fail(1)) SWIG_fail;
8192 {
8193 arg2 = (int)(SWIG_As_int(obj1));
8194 if (SWIG_arg_fail(2)) SWIG_fail;
8195 }
8196 {
8197 arg3 = (int)(SWIG_As_int(obj2));
8198 if (SWIG_arg_fail(3)) SWIG_fail;
8199 }
8200 {
8201 arg4 = wxString_in_helper(obj3);
8202 if (arg4 == NULL) SWIG_fail;
8203 temp4 = true;
8204 }
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (bool)(arg1)->base_CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 {
8213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8214 }
8215 {
8216 if (temp4)
8217 delete arg4;
8218 }
8219 return resultobj;
8220 fail:
8221 {
8222 if (temp4)
8223 delete arg4;
8224 }
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_PyGridTableBase_base_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8232 PyObject * obj0 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_Clear",kwnames,&obj0)) goto fail;
8238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8239 if (SWIG_arg_fail(1)) SWIG_fail;
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 (arg1)->base_Clear();
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 Py_INCREF(Py_None); resultobj = Py_None;
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_PyGridTableBase_base_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj;
8256 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8257 size_t arg2 = (size_t) 0 ;
8258 size_t arg3 = (size_t) 1 ;
8259 bool result;
8260 PyObject * obj0 = 0 ;
8261 PyObject * obj1 = 0 ;
8262 PyObject * obj2 = 0 ;
8263 char *kwnames[] = {
8264 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8265 };
8266
8267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8269 if (SWIG_arg_fail(1)) SWIG_fail;
8270 if (obj1) {
8271 {
8272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8273 if (SWIG_arg_fail(2)) SWIG_fail;
8274 }
8275 }
8276 if (obj2) {
8277 {
8278 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8279 if (SWIG_arg_fail(3)) SWIG_fail;
8280 }
8281 }
8282 {
8283 PyThreadState* __tstate = wxPyBeginAllowThreads();
8284 result = (bool)(arg1)->base_InsertRows(arg2,arg3);
8285
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 {
8290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8291 }
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 static PyObject *_wrap_PyGridTableBase_base_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj;
8300 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8301 size_t arg2 = (size_t) 1 ;
8302 bool result;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 char *kwnames[] = {
8306 (char *) "self",(char *) "numRows", NULL
8307 };
8308
8309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(1)) SWIG_fail;
8312 if (obj1) {
8313 {
8314 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 }
8317 }
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 result = (bool)(arg1)->base_AppendRows(arg2);
8321
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 {
8326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_PyGridTableBase_base_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8337 size_t arg2 = (size_t) 0 ;
8338 size_t arg3 = (size_t) 1 ;
8339 bool result;
8340 PyObject * obj0 = 0 ;
8341 PyObject * obj1 = 0 ;
8342 PyObject * obj2 = 0 ;
8343 char *kwnames[] = {
8344 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8345 };
8346
8347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteRows",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
8351 {
8352 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8353 if (SWIG_arg_fail(2)) SWIG_fail;
8354 }
8355 }
8356 if (obj2) {
8357 {
8358 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8359 if (SWIG_arg_fail(3)) SWIG_fail;
8360 }
8361 }
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (bool)(arg1)->base_DeleteRows(arg2,arg3);
8365
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 {
8370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8371 }
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_PyGridTableBase_base_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8381 size_t arg2 = (size_t) 0 ;
8382 size_t arg3 = (size_t) 1 ;
8383 bool result;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 if (obj1) {
8395 {
8396 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8397 if (SWIG_arg_fail(2)) SWIG_fail;
8398 }
8399 }
8400 if (obj2) {
8401 {
8402 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8403 if (SWIG_arg_fail(3)) SWIG_fail;
8404 }
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (bool)(arg1)->base_InsertCols(arg2,arg3);
8409
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 {
8414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8415 }
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 static PyObject *_wrap_PyGridTableBase_base_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj;
8424 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8425 size_t arg2 = (size_t) 1 ;
8426 bool result;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self",(char *) "numCols", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 if (obj1) {
8437 {
8438 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8439 if (SWIG_arg_fail(2)) SWIG_fail;
8440 }
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (bool)(arg1)->base_AppendCols(arg2);
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 {
8450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8451 }
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_PyGridTableBase_base_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj;
8460 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8461 size_t arg2 = (size_t) 0 ;
8462 size_t arg3 = (size_t) 1 ;
8463 bool result;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 PyObject * obj2 = 0 ;
8467 char *kwnames[] = {
8468 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8469 };
8470
8471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8473 if (SWIG_arg_fail(1)) SWIG_fail;
8474 if (obj1) {
8475 {
8476 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8477 if (SWIG_arg_fail(2)) SWIG_fail;
8478 }
8479 }
8480 if (obj2) {
8481 {
8482 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8483 if (SWIG_arg_fail(3)) SWIG_fail;
8484 }
8485 }
8486 {
8487 PyThreadState* __tstate = wxPyBeginAllowThreads();
8488 result = (bool)(arg1)->base_DeleteCols(arg2,arg3);
8489
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 {
8494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_PyGridTableBase_base_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8505 int arg2 ;
8506 wxString result;
8507 PyObject * obj0 = 0 ;
8508 PyObject * obj1 = 0 ;
8509 char *kwnames[] = {
8510 (char *) "self",(char *) "row", NULL
8511 };
8512
8513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8515 if (SWIG_arg_fail(1)) SWIG_fail;
8516 {
8517 arg2 = (int)(SWIG_As_int(obj1));
8518 if (SWIG_arg_fail(2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 result = (arg1)->base_GetRowLabelValue(arg2);
8523
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 #if wxUSE_UNICODE
8529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8530 #else
8531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8532 #endif
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_PyGridTableBase_base_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8543 int arg2 ;
8544 wxString result;
8545 PyObject * obj0 = 0 ;
8546 PyObject * obj1 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self",(char *) "col", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 arg2 = (int)(SWIG_As_int(obj1));
8556 if (SWIG_arg_fail(2)) SWIG_fail;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (arg1)->base_GetColLabelValue(arg2);
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 #if wxUSE_UNICODE
8567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8568 #else
8569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8570 #endif
8571 }
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_PyGridTableBase_base_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8581 int arg2 ;
8582 wxString *arg3 = 0 ;
8583 bool temp3 = false ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 PyObject * obj2 = 0 ;
8587 char *kwnames[] = {
8588 (char *) "self",(char *) "row",(char *) "value", NULL
8589 };
8590
8591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) 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 {
8595 arg2 = (int)(SWIG_As_int(obj1));
8596 if (SWIG_arg_fail(2)) SWIG_fail;
8597 }
8598 {
8599 arg3 = wxString_in_helper(obj2);
8600 if (arg3 == NULL) SWIG_fail;
8601 temp3 = true;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 (arg1)->base_SetRowLabelValue(arg2,(wxString const &)*arg3);
8606
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 Py_INCREF(Py_None); resultobj = Py_None;
8611 {
8612 if (temp3)
8613 delete arg3;
8614 }
8615 return resultobj;
8616 fail:
8617 {
8618 if (temp3)
8619 delete arg3;
8620 }
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_PyGridTableBase_base_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8628 int arg2 ;
8629 wxString *arg3 = 0 ;
8630 bool temp3 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 PyObject * obj2 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "col",(char *) "value", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = (int)(SWIG_As_int(obj1));
8643 if (SWIG_arg_fail(2)) SWIG_fail;
8644 }
8645 {
8646 arg3 = wxString_in_helper(obj2);
8647 if (arg3 == NULL) SWIG_fail;
8648 temp3 = true;
8649 }
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 (arg1)->base_SetColLabelValue(arg2,(wxString const &)*arg3);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 Py_INCREF(Py_None); resultobj = Py_None;
8658 {
8659 if (temp3)
8660 delete arg3;
8661 }
8662 return resultobj;
8663 fail:
8664 {
8665 if (temp3)
8666 delete arg3;
8667 }
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_PyGridTableBase_base_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj;
8674 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8675 bool result;
8676 PyObject * obj0 = 0 ;
8677 char *kwnames[] = {
8678 (char *) "self", NULL
8679 };
8680
8681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_CanHaveAttributes",kwnames,&obj0)) goto fail;
8682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8683 if (SWIG_arg_fail(1)) SWIG_fail;
8684 {
8685 PyThreadState* __tstate = wxPyBeginAllowThreads();
8686 result = (bool)(arg1)->base_CanHaveAttributes();
8687
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 {
8692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8693 }
8694 return resultobj;
8695 fail:
8696 return NULL;
8697 }
8698
8699
8700 static PyObject *_wrap_PyGridTableBase_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8701 PyObject *resultobj;
8702 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8703 int arg2 ;
8704 int arg3 ;
8705 wxGridCellAttr::wxAttrKind arg4 ;
8706 wxGridCellAttr *result;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 PyObject * obj2 = 0 ;
8710 PyObject * obj3 = 0 ;
8711 char *kwnames[] = {
8712 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 {
8719 arg2 = (int)(SWIG_As_int(obj1));
8720 if (SWIG_arg_fail(2)) SWIG_fail;
8721 }
8722 {
8723 arg3 = (int)(SWIG_As_int(obj2));
8724 if (SWIG_arg_fail(3)) SWIG_fail;
8725 }
8726 {
8727 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
8728 if (SWIG_arg_fail(4)) SWIG_fail;
8729 }
8730 {
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
8733
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 {
8738 resultobj = wxPyMake_wxGridCellAttr(result, 0);
8739 }
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 static PyObject *_wrap_PyGridTableBase_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj;
8748 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8749 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8750 int arg3 ;
8751 int arg4 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 PyObject * obj2 = 0 ;
8755 PyObject * obj3 = 0 ;
8756 char *kwnames[] = {
8757 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8764 if (SWIG_arg_fail(2)) SWIG_fail;
8765 {
8766 arg3 = (int)(SWIG_As_int(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 {
8770 arg4 = (int)(SWIG_As_int(obj3));
8771 if (SWIG_arg_fail(4)) SWIG_fail;
8772 }
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 (arg1)->base_SetAttr(arg2,arg3,arg4);
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 Py_INCREF(Py_None); resultobj = Py_None;
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 static PyObject *_wrap_PyGridTableBase_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8788 PyObject *resultobj;
8789 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8790 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8791 int arg3 ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 PyObject * obj2 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self",(char *) "attr",(char *) "row", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8803 if (SWIG_arg_fail(2)) SWIG_fail;
8804 {
8805 arg3 = (int)(SWIG_As_int(obj2));
8806 if (SWIG_arg_fail(3)) SWIG_fail;
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 (arg1)->base_SetRowAttr(arg2,arg3);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 Py_INCREF(Py_None); resultobj = Py_None;
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 static PyObject *_wrap_PyGridTableBase_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8823 PyObject *resultobj;
8824 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8825 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8826 int arg3 ;
8827 PyObject * obj0 = 0 ;
8828 PyObject * obj1 = 0 ;
8829 PyObject * obj2 = 0 ;
8830 char *kwnames[] = {
8831 (char *) "self",(char *) "attr",(char *) "col", NULL
8832 };
8833
8834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8836 if (SWIG_arg_fail(1)) SWIG_fail;
8837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(2)) SWIG_fail;
8839 {
8840 arg3 = (int)(SWIG_As_int(obj2));
8841 if (SWIG_arg_fail(3)) SWIG_fail;
8842 }
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 (arg1)->base_SetColAttr(arg2,arg3);
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 Py_INCREF(Py_None); resultobj = Py_None;
8851 return resultobj;
8852 fail:
8853 return NULL;
8854 }
8855
8856
8857 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
8858 PyObject *obj;
8859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8860 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
8861 Py_INCREF(obj);
8862 return Py_BuildValue((char *)"");
8863 }
8864 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
8865 PyObject *resultobj;
8866 int arg1 = (int) 0 ;
8867 int arg2 = (int) 0 ;
8868 wxGridStringTable *result;
8869 PyObject * obj0 = 0 ;
8870 PyObject * obj1 = 0 ;
8871 char *kwnames[] = {
8872 (char *) "numRows",(char *) "numCols", NULL
8873 };
8874
8875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
8876 if (obj0) {
8877 {
8878 arg1 = (int)(SWIG_As_int(obj0));
8879 if (SWIG_arg_fail(1)) SWIG_fail;
8880 }
8881 }
8882 if (obj1) {
8883 {
8884 arg2 = (int)(SWIG_As_int(obj1));
8885 if (SWIG_arg_fail(2)) SWIG_fail;
8886 }
8887 }
8888 {
8889 PyThreadState* __tstate = wxPyBeginAllowThreads();
8890 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
8891
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
8903 PyObject *obj;
8904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8905 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
8906 Py_INCREF(obj);
8907 return Py_BuildValue((char *)"");
8908 }
8909 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8910 PyObject *resultobj;
8911 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8912 int arg2 ;
8913 int arg3 = (int) -1 ;
8914 int arg4 = (int) -1 ;
8915 wxGridTableMessage *result;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 PyObject * obj3 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 arg2 = (int)(SWIG_As_int(obj1));
8929 if (SWIG_arg_fail(2)) SWIG_fail;
8930 }
8931 if (obj2) {
8932 {
8933 arg3 = (int)(SWIG_As_int(obj2));
8934 if (SWIG_arg_fail(3)) SWIG_fail;
8935 }
8936 }
8937 if (obj3) {
8938 {
8939 arg4 = (int)(SWIG_As_int(obj3));
8940 if (SWIG_arg_fail(4)) SWIG_fail;
8941 }
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
8946
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj;
8959 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8960 PyObject * obj0 = 0 ;
8961 char *kwnames[] = {
8962 (char *) "self", NULL
8963 };
8964
8965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
8966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8967 if (SWIG_arg_fail(1)) SWIG_fail;
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 delete arg1;
8971
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 Py_INCREF(Py_None); resultobj = Py_None;
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8985 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
8986 PyObject * obj0 = 0 ;
8987 PyObject * obj1 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "table", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 (arg1)->SetTableObject(arg2);
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 Py_INCREF(Py_None); resultobj = Py_None;
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9014 wxGridTableBase *result;
9015 PyObject * obj0 = 0 ;
9016 char *kwnames[] = {
9017 (char *) "self", NULL
9018 };
9019
9020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9022 if (SWIG_arg_fail(1)) SWIG_fail;
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 {
9031 resultobj = wxPyMake_wxGridTableBase(result, 0);
9032 }
9033 return resultobj;
9034 fail:
9035 return NULL;
9036 }
9037
9038
9039 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj;
9041 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9042 int arg2 ;
9043 PyObject * obj0 = 0 ;
9044 PyObject * obj1 = 0 ;
9045 char *kwnames[] = {
9046 (char *) "self",(char *) "id", NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9051 if (SWIG_arg_fail(1)) SWIG_fail;
9052 {
9053 arg2 = (int)(SWIG_As_int(obj1));
9054 if (SWIG_arg_fail(2)) SWIG_fail;
9055 }
9056 {
9057 PyThreadState* __tstate = wxPyBeginAllowThreads();
9058 (arg1)->SetId(arg2);
9059
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 Py_INCREF(Py_None); resultobj = Py_None;
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj;
9072 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9073 int result;
9074 PyObject * obj0 = 0 ;
9075 char *kwnames[] = {
9076 (char *) "self", NULL
9077 };
9078
9079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9081 if (SWIG_arg_fail(1)) SWIG_fail;
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 result = (int)(arg1)->GetId();
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 {
9090 resultobj = SWIG_From_int((int)(result));
9091 }
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9101 int arg2 ;
9102 PyObject * obj0 = 0 ;
9103 PyObject * obj1 = 0 ;
9104 char *kwnames[] = {
9105 (char *) "self",(char *) "comInt1", NULL
9106 };
9107
9108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9110 if (SWIG_arg_fail(1)) SWIG_fail;
9111 {
9112 arg2 = (int)(SWIG_As_int(obj1));
9113 if (SWIG_arg_fail(2)) SWIG_fail;
9114 }
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 (arg1)->SetCommandInt(arg2);
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 Py_INCREF(Py_None); resultobj = Py_None;
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj;
9131 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9132 int result;
9133 PyObject * obj0 = 0 ;
9134 char *kwnames[] = {
9135 (char *) "self", NULL
9136 };
9137
9138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9140 if (SWIG_arg_fail(1)) SWIG_fail;
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 result = (int)(arg1)->GetCommandInt();
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 {
9149 resultobj = SWIG_From_int((int)(result));
9150 }
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9160 int arg2 ;
9161 PyObject * obj0 = 0 ;
9162 PyObject * obj1 = 0 ;
9163 char *kwnames[] = {
9164 (char *) "self",(char *) "comInt2", NULL
9165 };
9166
9167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 {
9171 arg2 = (int)(SWIG_As_int(obj1));
9172 if (SWIG_arg_fail(2)) SWIG_fail;
9173 }
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 (arg1)->SetCommandInt2(arg2);
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 Py_INCREF(Py_None); resultobj = Py_None;
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj;
9190 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9191 int result;
9192 PyObject * obj0 = 0 ;
9193 char *kwnames[] = {
9194 (char *) "self", NULL
9195 };
9196
9197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9199 if (SWIG_arg_fail(1)) SWIG_fail;
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (int)(arg1)->GetCommandInt2();
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 {
9208 resultobj = SWIG_From_int((int)(result));
9209 }
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9217 PyObject *obj;
9218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9219 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9220 Py_INCREF(obj);
9221 return Py_BuildValue((char *)"");
9222 }
9223 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 int arg1 = (int) -1 ;
9226 int arg2 = (int) -1 ;
9227 wxGridCellCoords *result;
9228 PyObject * obj0 = 0 ;
9229 PyObject * obj1 = 0 ;
9230 char *kwnames[] = {
9231 (char *) "r",(char *) "c", NULL
9232 };
9233
9234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9235 if (obj0) {
9236 {
9237 arg1 = (int)(SWIG_As_int(obj0));
9238 if (SWIG_arg_fail(1)) SWIG_fail;
9239 }
9240 }
9241 if (obj1) {
9242 {
9243 arg2 = (int)(SWIG_As_int(obj1));
9244 if (SWIG_arg_fail(2)) SWIG_fail;
9245 }
9246 }
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9250
9251 wxPyEndAllowThreads(__tstate);
9252 if (PyErr_Occurred()) SWIG_fail;
9253 }
9254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj;
9263 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9264 PyObject * obj0 = 0 ;
9265 char *kwnames[] = {
9266 (char *) "self", NULL
9267 };
9268
9269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9271 if (SWIG_arg_fail(1)) SWIG_fail;
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 delete arg1;
9275
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 Py_INCREF(Py_None); resultobj = Py_None;
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj;
9288 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9289 int result;
9290 PyObject * obj0 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 {
9306 resultobj = SWIG_From_int((int)(result));
9307 }
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9317 int arg2 ;
9318 PyObject * obj0 = 0 ;
9319 PyObject * obj1 = 0 ;
9320 char *kwnames[] = {
9321 (char *) "self",(char *) "n", NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9326 if (SWIG_arg_fail(1)) SWIG_fail;
9327 {
9328 arg2 = (int)(SWIG_As_int(obj1));
9329 if (SWIG_arg_fail(2)) SWIG_fail;
9330 }
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 (arg1)->SetRow(arg2);
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 Py_INCREF(Py_None); resultobj = Py_None;
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9346 PyObject *resultobj;
9347 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9348 int result;
9349 PyObject * obj0 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 {
9365 resultobj = SWIG_From_int((int)(result));
9366 }
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj;
9375 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9376 int arg2 ;
9377 PyObject * obj0 = 0 ;
9378 PyObject * obj1 = 0 ;
9379 char *kwnames[] = {
9380 (char *) "self",(char *) "n", NULL
9381 };
9382
9383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9385 if (SWIG_arg_fail(1)) SWIG_fail;
9386 {
9387 arg2 = (int)(SWIG_As_int(obj1));
9388 if (SWIG_arg_fail(2)) SWIG_fail;
9389 }
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 (arg1)->SetCol(arg2);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 Py_INCREF(Py_None); resultobj = Py_None;
9398 return resultobj;
9399 fail:
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9407 int arg2 ;
9408 int arg3 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 PyObject * obj2 = 0 ;
9412 char *kwnames[] = {
9413 (char *) "self",(char *) "row",(char *) "col", NULL
9414 };
9415
9416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9418 if (SWIG_arg_fail(1)) SWIG_fail;
9419 {
9420 arg2 = (int)(SWIG_As_int(obj1));
9421 if (SWIG_arg_fail(2)) SWIG_fail;
9422 }
9423 {
9424 arg3 = (int)(SWIG_As_int(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 (arg1)->Set(arg2,arg3);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 Py_INCREF(Py_None); resultobj = Py_None;
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj;
9443 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9444 wxGridCellCoords *arg2 = 0 ;
9445 bool result;
9446 wxGridCellCoords temp2 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 char *kwnames[] = {
9450 (char *) "self",(char *) "other", NULL
9451 };
9452
9453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
9458 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 {
9468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9469 }
9470 return resultobj;
9471 fail:
9472 return NULL;
9473 }
9474
9475
9476 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9477 PyObject *resultobj;
9478 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9479 wxGridCellCoords *arg2 = 0 ;
9480 bool result;
9481 wxGridCellCoords temp2 ;
9482 PyObject * obj0 = 0 ;
9483 PyObject * obj1 = 0 ;
9484 char *kwnames[] = {
9485 (char *) "self",(char *) "other", NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9490 if (SWIG_arg_fail(1)) SWIG_fail;
9491 {
9492 arg2 = &temp2;
9493 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9494 }
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9498
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 {
9503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9504 }
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj;
9513 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9514 PyObject *result;
9515 PyObject * obj0 = 0 ;
9516 char *kwnames[] = {
9517 (char *) "self", NULL
9518 };
9519
9520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9522 if (SWIG_arg_fail(1)) SWIG_fail;
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (PyObject *)wxGridCellCoords_Get(arg1);
9526
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 resultobj = result;
9531 return resultobj;
9532 fail:
9533 return NULL;
9534 }
9535
9536
9537 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9538 PyObject *obj;
9539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9540 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9541 Py_INCREF(obj);
9542 return Py_BuildValue((char *)"");
9543 }
9544 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj;
9546 wxWindow *arg1 = (wxWindow *) 0 ;
9547 int arg2 = (int) -1 ;
9548 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9549 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9550 wxSize const &arg4_defvalue = wxDefaultSize ;
9551 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9552 long arg5 = (long) wxWANTS_CHARS ;
9553 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9554 wxString *arg6 = (wxString *) &arg6_defvalue ;
9555 wxGrid *result;
9556 wxPoint temp3 ;
9557 wxSize temp4 ;
9558 bool temp6 = false ;
9559 PyObject * obj0 = 0 ;
9560 PyObject * obj1 = 0 ;
9561 PyObject * obj2 = 0 ;
9562 PyObject * obj3 = 0 ;
9563 PyObject * obj4 = 0 ;
9564 PyObject * obj5 = 0 ;
9565 char *kwnames[] = {
9566 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9567 };
9568
9569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9571 if (SWIG_arg_fail(1)) SWIG_fail;
9572 if (obj1) {
9573 {
9574 arg2 = (int)(SWIG_As_int(obj1));
9575 if (SWIG_arg_fail(2)) SWIG_fail;
9576 }
9577 }
9578 if (obj2) {
9579 {
9580 arg3 = &temp3;
9581 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9582 }
9583 }
9584 if (obj3) {
9585 {
9586 arg4 = &temp4;
9587 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9588 }
9589 }
9590 if (obj4) {
9591 {
9592 arg5 = (long)(SWIG_As_long(obj4));
9593 if (SWIG_arg_fail(5)) SWIG_fail;
9594 }
9595 }
9596 if (obj5) {
9597 {
9598 arg6 = wxString_in_helper(obj5);
9599 if (arg6 == NULL) SWIG_fail;
9600 temp6 = true;
9601 }
9602 }
9603 {
9604 if (!wxPyCheckForApp()) SWIG_fail;
9605 PyThreadState* __tstate = wxPyBeginAllowThreads();
9606 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9607
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9612 {
9613 if (temp6)
9614 delete arg6;
9615 }
9616 return resultobj;
9617 fail:
9618 {
9619 if (temp6)
9620 delete arg6;
9621 }
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxGrid *result;
9629 char *kwnames[] = {
9630 NULL
9631 };
9632
9633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9634 {
9635 if (!wxPyCheckForApp()) SWIG_fail;
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 result = (wxGrid *)new wxGrid();
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxGrid *arg1 = (wxGrid *) 0 ;
9652 wxWindow *arg2 = (wxWindow *) 0 ;
9653 int arg3 = (int) -1 ;
9654 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9655 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9656 wxSize const &arg5_defvalue = wxDefaultSize ;
9657 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9658 long arg6 = (long) wxWANTS_CHARS ;
9659 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9660 wxString *arg7 = (wxString *) &arg7_defvalue ;
9661 bool result;
9662 wxPoint temp4 ;
9663 wxSize temp5 ;
9664 bool temp7 = false ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 PyObject * obj2 = 0 ;
9668 PyObject * obj3 = 0 ;
9669 PyObject * obj4 = 0 ;
9670 PyObject * obj5 = 0 ;
9671 PyObject * obj6 = 0 ;
9672 char *kwnames[] = {
9673 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9674 };
9675
9676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9678 if (SWIG_arg_fail(1)) SWIG_fail;
9679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9680 if (SWIG_arg_fail(2)) SWIG_fail;
9681 if (obj2) {
9682 {
9683 arg3 = (int)(SWIG_As_int(obj2));
9684 if (SWIG_arg_fail(3)) SWIG_fail;
9685 }
9686 }
9687 if (obj3) {
9688 {
9689 arg4 = &temp4;
9690 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9691 }
9692 }
9693 if (obj4) {
9694 {
9695 arg5 = &temp5;
9696 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9697 }
9698 }
9699 if (obj5) {
9700 {
9701 arg6 = (long)(SWIG_As_long(obj5));
9702 if (SWIG_arg_fail(6)) SWIG_fail;
9703 }
9704 }
9705 if (obj6) {
9706 {
9707 arg7 = wxString_in_helper(obj6);
9708 if (arg7 == NULL) SWIG_fail;
9709 temp7 = true;
9710 }
9711 }
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 {
9720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9721 }
9722 {
9723 if (temp7)
9724 delete arg7;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp7)
9730 delete arg7;
9731 }
9732 return NULL;
9733 }
9734
9735
9736 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj;
9738 wxGrid *arg1 = (wxGrid *) 0 ;
9739 int arg2 ;
9740 int arg3 ;
9741 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9742 bool result;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 PyObject * obj2 = 0 ;
9746 PyObject * obj3 = 0 ;
9747 char *kwnames[] = {
9748 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9749 };
9750
9751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9753 if (SWIG_arg_fail(1)) SWIG_fail;
9754 {
9755 arg2 = (int)(SWIG_As_int(obj1));
9756 if (SWIG_arg_fail(2)) SWIG_fail;
9757 }
9758 {
9759 arg3 = (int)(SWIG_As_int(obj2));
9760 if (SWIG_arg_fail(3)) SWIG_fail;
9761 }
9762 if (obj3) {
9763 {
9764 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9765 if (SWIG_arg_fail(4)) SWIG_fail;
9766 }
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj;
9786 wxGrid *arg1 = (wxGrid *) 0 ;
9787 WXGRIDSELECTIONMODES arg2 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self",(char *) "selmode", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 arg2 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj1));
9799 if (SWIG_arg_fail(2)) SWIG_fail;
9800 }
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 (arg1)->SetSelectionMode(arg2);
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 Py_INCREF(Py_None); resultobj = Py_None;
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj;
9817 wxGrid *arg1 = (wxGrid *) 0 ;
9818 WXGRIDSELECTIONMODES result;
9819 PyObject * obj0 = 0 ;
9820 char *kwnames[] = {
9821 (char *) "self", NULL
9822 };
9823
9824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
9825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9826 if (SWIG_arg_fail(1)) SWIG_fail;
9827 {
9828 PyThreadState* __tstate = wxPyBeginAllowThreads();
9829 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
9830
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 {
9835 resultobj = SWIG_From_int((int)(result));
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxGrid *arg1 = (wxGrid *) 0 ;
9846 int result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (int)(arg1)->GetNumberRows();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 {
9863 resultobj = SWIG_From_int((int)(result));
9864 }
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxGrid *arg1 = (wxGrid *) 0 ;
9874 int result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (int)(arg1)->GetNumberCols();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 resultobj = SWIG_From_int((int)(result));
9892 }
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxGrid *arg1 = (wxGrid *) 0 ;
9902 wxGridTableMessage *arg2 = 0 ;
9903 bool result;
9904 PyObject * obj0 = 0 ;
9905 PyObject * obj1 = 0 ;
9906 char *kwnames[] = {
9907 (char *) "self","arg2", NULL
9908 };
9909
9910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
9911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9912 if (SWIG_arg_fail(1)) SWIG_fail;
9913 {
9914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9915 if (SWIG_arg_fail(2)) SWIG_fail;
9916 if (arg2 == NULL) {
9917 SWIG_null_ref("wxGridTableMessage");
9918 }
9919 if (SWIG_arg_fail(2)) SWIG_fail;
9920 }
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (bool)(arg1)->ProcessTableMessage(*arg2);
9924
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 {
9929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9930 }
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxGrid *arg1 = (wxGrid *) 0 ;
9940 wxGridTableBase *result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "self", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
9947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
9952
9953 wxPyEndAllowThreads(__tstate);
9954 if (PyErr_Occurred()) SWIG_fail;
9955 }
9956 {
9957 resultobj = wxPyMake_wxGridTableBase(result, 0);
9958 }
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9966 PyObject *resultobj;
9967 wxGrid *arg1 = (wxGrid *) 0 ;
9968 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9969 bool arg3 = (bool) false ;
9970 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9971 bool result;
9972 PyObject * obj0 = 0 ;
9973 PyObject * obj1 = 0 ;
9974 PyObject * obj2 = 0 ;
9975 PyObject * obj3 = 0 ;
9976 char *kwnames[] = {
9977 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
9978 };
9979
9980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9982 if (SWIG_arg_fail(1)) SWIG_fail;
9983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9984 if (SWIG_arg_fail(2)) SWIG_fail;
9985 if (obj2) {
9986 {
9987 arg3 = (bool)(SWIG_As_bool(obj2));
9988 if (SWIG_arg_fail(3)) SWIG_fail;
9989 }
9990 }
9991 if (obj3) {
9992 {
9993 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9994 if (SWIG_arg_fail(4)) SWIG_fail;
9995 }
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 return resultobj;
10008 fail:
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxGrid *arg1 = (wxGrid *) 0 ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "self", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10023 if (SWIG_arg_fail(1)) SWIG_fail;
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 (arg1)->ClearGrid();
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 Py_INCREF(Py_None); resultobj = Py_None;
10032 return resultobj;
10033 fail:
10034 return NULL;
10035 }
10036
10037
10038 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxGrid *arg1 = (wxGrid *) 0 ;
10041 int arg2 = (int) 0 ;
10042 int arg3 = (int) 1 ;
10043 bool arg4 = (bool) true ;
10044 bool result;
10045 PyObject * obj0 = 0 ;
10046 PyObject * obj1 = 0 ;
10047 PyObject * obj2 = 0 ;
10048 PyObject * obj3 = 0 ;
10049 char *kwnames[] = {
10050 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10051 };
10052
10053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10055 if (SWIG_arg_fail(1)) SWIG_fail;
10056 if (obj1) {
10057 {
10058 arg2 = (int)(SWIG_As_int(obj1));
10059 if (SWIG_arg_fail(2)) SWIG_fail;
10060 }
10061 }
10062 if (obj2) {
10063 {
10064 arg3 = (int)(SWIG_As_int(obj2));
10065 if (SWIG_arg_fail(3)) SWIG_fail;
10066 }
10067 }
10068 if (obj3) {
10069 {
10070 arg4 = (bool)(SWIG_As_bool(obj3));
10071 if (SWIG_arg_fail(4)) SWIG_fail;
10072 }
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 {
10082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10083 }
10084 return resultobj;
10085 fail:
10086 return NULL;
10087 }
10088
10089
10090 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10091 PyObject *resultobj;
10092 wxGrid *arg1 = (wxGrid *) 0 ;
10093 int arg2 = (int) 1 ;
10094 bool arg3 = (bool) true ;
10095 bool result;
10096 PyObject * obj0 = 0 ;
10097 PyObject * obj1 = 0 ;
10098 PyObject * obj2 = 0 ;
10099 char *kwnames[] = {
10100 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10101 };
10102
10103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10105 if (SWIG_arg_fail(1)) SWIG_fail;
10106 if (obj1) {
10107 {
10108 arg2 = (int)(SWIG_As_int(obj1));
10109 if (SWIG_arg_fail(2)) SWIG_fail;
10110 }
10111 }
10112 if (obj2) {
10113 {
10114 arg3 = (bool)(SWIG_As_bool(obj2));
10115 if (SWIG_arg_fail(3)) SWIG_fail;
10116 }
10117 }
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 result = (bool)(arg1)->AppendRows(arg2,arg3);
10121
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 {
10126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10127 }
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxGrid *arg1 = (wxGrid *) 0 ;
10137 int arg2 = (int) 0 ;
10138 int arg3 = (int) 1 ;
10139 bool arg4 = (bool) true ;
10140 bool result;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 PyObject * obj2 = 0 ;
10144 PyObject * obj3 = 0 ;
10145 char *kwnames[] = {
10146 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10147 };
10148
10149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10151 if (SWIG_arg_fail(1)) SWIG_fail;
10152 if (obj1) {
10153 {
10154 arg2 = (int)(SWIG_As_int(obj1));
10155 if (SWIG_arg_fail(2)) SWIG_fail;
10156 }
10157 }
10158 if (obj2) {
10159 {
10160 arg3 = (int)(SWIG_As_int(obj2));
10161 if (SWIG_arg_fail(3)) SWIG_fail;
10162 }
10163 }
10164 if (obj3) {
10165 {
10166 arg4 = (bool)(SWIG_As_bool(obj3));
10167 if (SWIG_arg_fail(4)) SWIG_fail;
10168 }
10169 }
10170 {
10171 PyThreadState* __tstate = wxPyBeginAllowThreads();
10172 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10173
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 {
10178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10179 }
10180 return resultobj;
10181 fail:
10182 return NULL;
10183 }
10184
10185
10186 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj;
10188 wxGrid *arg1 = (wxGrid *) 0 ;
10189 int arg2 = (int) 0 ;
10190 int arg3 = (int) 1 ;
10191 bool arg4 = (bool) true ;
10192 bool result;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 PyObject * obj2 = 0 ;
10196 PyObject * obj3 = 0 ;
10197 char *kwnames[] = {
10198 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10199 };
10200
10201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10203 if (SWIG_arg_fail(1)) SWIG_fail;
10204 if (obj1) {
10205 {
10206 arg2 = (int)(SWIG_As_int(obj1));
10207 if (SWIG_arg_fail(2)) SWIG_fail;
10208 }
10209 }
10210 if (obj2) {
10211 {
10212 arg3 = (int)(SWIG_As_int(obj2));
10213 if (SWIG_arg_fail(3)) SWIG_fail;
10214 }
10215 }
10216 if (obj3) {
10217 {
10218 arg4 = (bool)(SWIG_As_bool(obj3));
10219 if (SWIG_arg_fail(4)) SWIG_fail;
10220 }
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10225
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 {
10230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10231 }
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 wxGrid *arg1 = (wxGrid *) 0 ;
10241 int arg2 = (int) 1 ;
10242 bool arg3 = (bool) true ;
10243 bool result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10253 if (SWIG_arg_fail(1)) SWIG_fail;
10254 if (obj1) {
10255 {
10256 arg2 = (int)(SWIG_As_int(obj1));
10257 if (SWIG_arg_fail(2)) SWIG_fail;
10258 }
10259 }
10260 if (obj2) {
10261 {
10262 arg3 = (bool)(SWIG_As_bool(obj2));
10263 if (SWIG_arg_fail(3)) SWIG_fail;
10264 }
10265 }
10266 {
10267 PyThreadState* __tstate = wxPyBeginAllowThreads();
10268 result = (bool)(arg1)->AppendCols(arg2,arg3);
10269
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10275 }
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxGrid *arg1 = (wxGrid *) 0 ;
10285 int arg2 = (int) 0 ;
10286 int arg3 = (int) 1 ;
10287 bool arg4 = (bool) true ;
10288 bool result;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 PyObject * obj2 = 0 ;
10292 PyObject * obj3 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10295 };
10296
10297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10299 if (SWIG_arg_fail(1)) SWIG_fail;
10300 if (obj1) {
10301 {
10302 arg2 = (int)(SWIG_As_int(obj1));
10303 if (SWIG_arg_fail(2)) SWIG_fail;
10304 }
10305 }
10306 if (obj2) {
10307 {
10308 arg3 = (int)(SWIG_As_int(obj2));
10309 if (SWIG_arg_fail(3)) SWIG_fail;
10310 }
10311 }
10312 if (obj3) {
10313 {
10314 arg4 = (bool)(SWIG_As_bool(obj3));
10315 if (SWIG_arg_fail(4)) SWIG_fail;
10316 }
10317 }
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10321
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10327 }
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxGrid *arg1 = (wxGrid *) 0 ;
10337 wxDC *arg2 = 0 ;
10338 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 PyObject * obj2 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "self",(char *) "dc",(char *) "attr", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(1)) SWIG_fail;
10349 {
10350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10351 if (SWIG_arg_fail(2)) SWIG_fail;
10352 if (arg2 == NULL) {
10353 SWIG_null_ref("wxDC");
10354 }
10355 if (SWIG_arg_fail(2)) SWIG_fail;
10356 }
10357 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(3)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxGrid *arg1 = (wxGrid *) 0 ;
10376 wxDC *arg2 = 0 ;
10377 wxString *arg3 = 0 ;
10378 wxRect *arg4 = 0 ;
10379 int arg5 = (int) wxLEFT ;
10380 int arg6 = (int) wxTOP ;
10381 int arg7 = (int) wxHORIZONTAL ;
10382 bool temp3 = false ;
10383 wxRect temp4 ;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 PyObject * obj3 = 0 ;
10388 PyObject * obj4 = 0 ;
10389 PyObject * obj5 = 0 ;
10390 PyObject * obj6 = 0 ;
10391 char *kwnames[] = {
10392 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10393 };
10394
10395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10397 if (SWIG_arg_fail(1)) SWIG_fail;
10398 {
10399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10400 if (SWIG_arg_fail(2)) SWIG_fail;
10401 if (arg2 == NULL) {
10402 SWIG_null_ref("wxDC");
10403 }
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = wxString_in_helper(obj2);
10408 if (arg3 == NULL) SWIG_fail;
10409 temp3 = true;
10410 }
10411 {
10412 arg4 = &temp4;
10413 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10414 }
10415 if (obj4) {
10416 {
10417 arg5 = (int)(SWIG_As_int(obj4));
10418 if (SWIG_arg_fail(5)) SWIG_fail;
10419 }
10420 }
10421 if (obj5) {
10422 {
10423 arg6 = (int)(SWIG_As_int(obj5));
10424 if (SWIG_arg_fail(6)) SWIG_fail;
10425 }
10426 }
10427 if (obj6) {
10428 {
10429 arg7 = (int)(SWIG_As_int(obj6));
10430 if (SWIG_arg_fail(7)) SWIG_fail;
10431 }
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 Py_INCREF(Py_None); resultobj = Py_None;
10441 {
10442 if (temp3)
10443 delete arg3;
10444 }
10445 return resultobj;
10446 fail:
10447 {
10448 if (temp3)
10449 delete arg3;
10450 }
10451 return NULL;
10452 }
10453
10454
10455 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10456 PyObject *resultobj;
10457 wxGrid *arg1 = (wxGrid *) 0 ;
10458 wxDC *arg2 = 0 ;
10459 wxArrayString *arg3 = 0 ;
10460 long *arg4 = (long *) 0 ;
10461 long *arg5 = (long *) 0 ;
10462 bool temp3 = false ;
10463 long temp4 ;
10464 int res4 = 0 ;
10465 long temp5 ;
10466 int res5 = 0 ;
10467 PyObject * obj0 = 0 ;
10468 PyObject * obj1 = 0 ;
10469 PyObject * obj2 = 0 ;
10470 char *kwnames[] = {
10471 (char *) "self",(char *) "dc",(char *) "lines", NULL
10472 };
10473
10474 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10475 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10478 if (SWIG_arg_fail(1)) SWIG_fail;
10479 {
10480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10481 if (SWIG_arg_fail(2)) SWIG_fail;
10482 if (arg2 == NULL) {
10483 SWIG_null_ref("wxDC");
10484 }
10485 if (SWIG_arg_fail(2)) SWIG_fail;
10486 }
10487 {
10488 if (! PySequence_Check(obj2)) {
10489 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10490 SWIG_fail;
10491 }
10492 arg3 = new wxArrayString;
10493 temp3 = true;
10494 int i, len=PySequence_Length(obj2);
10495 for (i=0; i<len; i++) {
10496 PyObject* item = PySequence_GetItem(obj2, i);
10497 wxString* s = wxString_in_helper(item);
10498 if (PyErr_Occurred()) SWIG_fail;
10499 arg3->Add(*s);
10500 delete s;
10501 Py_DECREF(item);
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 Py_INCREF(Py_None); resultobj = Py_None;
10512 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10513 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10514 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10515 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10516 {
10517 if (temp3) delete arg3;
10518 }
10519 return resultobj;
10520 fail:
10521 {
10522 if (temp3) delete arg3;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxGrid *arg1 = (wxGrid *) 0 ;
10531 PyObject * obj0 = 0 ;
10532 char *kwnames[] = {
10533 (char *) "self", NULL
10534 };
10535
10536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10538 if (SWIG_arg_fail(1)) SWIG_fail;
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 (arg1)->BeginBatch();
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 Py_INCREF(Py_None); resultobj = Py_None;
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj;
10555 wxGrid *arg1 = (wxGrid *) 0 ;
10556 PyObject * obj0 = 0 ;
10557 char *kwnames[] = {
10558 (char *) "self", NULL
10559 };
10560
10561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10563 if (SWIG_arg_fail(1)) SWIG_fail;
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 (arg1)->EndBatch();
10567
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 Py_INCREF(Py_None); resultobj = Py_None;
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10579 PyObject *resultobj;
10580 wxGrid *arg1 = (wxGrid *) 0 ;
10581 int result;
10582 PyObject * obj0 = 0 ;
10583 char *kwnames[] = {
10584 (char *) "self", NULL
10585 };
10586
10587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10589 if (SWIG_arg_fail(1)) SWIG_fail;
10590 {
10591 PyThreadState* __tstate = wxPyBeginAllowThreads();
10592 result = (int)(arg1)->GetBatchCount();
10593
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 resultobj = SWIG_From_int((int)(result));
10599 }
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj;
10608 wxGrid *arg1 = (wxGrid *) 0 ;
10609 PyObject * obj0 = 0 ;
10610 char *kwnames[] = {
10611 (char *) "self", NULL
10612 };
10613
10614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 (arg1)->ForceRefresh();
10620
10621 wxPyEndAllowThreads(__tstate);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 Py_INCREF(Py_None); resultobj = Py_None;
10625 return resultobj;
10626 fail:
10627 return NULL;
10628 }
10629
10630
10631 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj;
10633 wxGrid *arg1 = (wxGrid *) 0 ;
10634 bool result;
10635 PyObject * obj0 = 0 ;
10636 char *kwnames[] = {
10637 (char *) "self", NULL
10638 };
10639
10640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10642 if (SWIG_arg_fail(1)) SWIG_fail;
10643 {
10644 PyThreadState* __tstate = wxPyBeginAllowThreads();
10645 result = (bool)(arg1)->IsEditable();
10646
10647 wxPyEndAllowThreads(__tstate);
10648 if (PyErr_Occurred()) SWIG_fail;
10649 }
10650 {
10651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10652 }
10653 return resultobj;
10654 fail:
10655 return NULL;
10656 }
10657
10658
10659 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj;
10661 wxGrid *arg1 = (wxGrid *) 0 ;
10662 bool arg2 ;
10663 PyObject * obj0 = 0 ;
10664 PyObject * obj1 = 0 ;
10665 char *kwnames[] = {
10666 (char *) "self",(char *) "edit", NULL
10667 };
10668
10669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10671 if (SWIG_arg_fail(1)) SWIG_fail;
10672 {
10673 arg2 = (bool)(SWIG_As_bool(obj1));
10674 if (SWIG_arg_fail(2)) SWIG_fail;
10675 }
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 (arg1)->EnableEditing(arg2);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 Py_INCREF(Py_None); resultobj = Py_None;
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 wxGrid *arg1 = (wxGrid *) 0 ;
10693 bool arg2 = (bool) true ;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 char *kwnames[] = {
10697 (char *) "self",(char *) "enable", NULL
10698 };
10699
10700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10702 if (SWIG_arg_fail(1)) SWIG_fail;
10703 if (obj1) {
10704 {
10705 arg2 = (bool)(SWIG_As_bool(obj1));
10706 if (SWIG_arg_fail(2)) SWIG_fail;
10707 }
10708 }
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 (arg1)->EnableCellEditControl(arg2);
10712
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 Py_INCREF(Py_None); resultobj = Py_None;
10717 return resultobj;
10718 fail:
10719 return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10724 PyObject *resultobj;
10725 wxGrid *arg1 = (wxGrid *) 0 ;
10726 PyObject * obj0 = 0 ;
10727 char *kwnames[] = {
10728 (char *) "self", NULL
10729 };
10730
10731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10733 if (SWIG_arg_fail(1)) SWIG_fail;
10734 {
10735 PyThreadState* __tstate = wxPyBeginAllowThreads();
10736 (arg1)->DisableCellEditControl();
10737
10738 wxPyEndAllowThreads(__tstate);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 Py_INCREF(Py_None); resultobj = Py_None;
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj;
10750 wxGrid *arg1 = (wxGrid *) 0 ;
10751 bool result;
10752 PyObject * obj0 = 0 ;
10753 char *kwnames[] = {
10754 (char *) "self", NULL
10755 };
10756
10757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10759 if (SWIG_arg_fail(1)) SWIG_fail;
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10763
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 {
10768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10769 }
10770 return resultobj;
10771 fail:
10772 return NULL;
10773 }
10774
10775
10776 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10777 PyObject *resultobj;
10778 wxGrid *arg1 = (wxGrid *) 0 ;
10779 bool result;
10780 PyObject * obj0 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "self", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10797 }
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj;
10806 wxGrid *arg1 = (wxGrid *) 0 ;
10807 bool result;
10808 PyObject * obj0 = 0 ;
10809 char *kwnames[] = {
10810 (char *) "self", NULL
10811 };
10812
10813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
10814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10815 if (SWIG_arg_fail(1)) SWIG_fail;
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10825 }
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
10833 PyObject *resultobj;
10834 wxGrid *arg1 = (wxGrid *) 0 ;
10835 bool result;
10836 PyObject * obj0 = 0 ;
10837 char *kwnames[] = {
10838 (char *) "self", NULL
10839 };
10840
10841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
10842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10843 if (SWIG_arg_fail(1)) SWIG_fail;
10844 {
10845 PyThreadState* __tstate = wxPyBeginAllowThreads();
10846 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
10847
10848 wxPyEndAllowThreads(__tstate);
10849 if (PyErr_Occurred()) SWIG_fail;
10850 }
10851 {
10852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10853 }
10854 return resultobj;
10855 fail:
10856 return NULL;
10857 }
10858
10859
10860 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10861 PyObject *resultobj;
10862 wxGrid *arg1 = (wxGrid *) 0 ;
10863 PyObject * obj0 = 0 ;
10864 char *kwnames[] = {
10865 (char *) "self", NULL
10866 };
10867
10868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
10869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10870 if (SWIG_arg_fail(1)) SWIG_fail;
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 (arg1)->ShowCellEditControl();
10874
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 Py_INCREF(Py_None); resultobj = Py_None;
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj;
10887 wxGrid *arg1 = (wxGrid *) 0 ;
10888 PyObject * obj0 = 0 ;
10889 char *kwnames[] = {
10890 (char *) "self", NULL
10891 };
10892
10893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
10894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10895 if (SWIG_arg_fail(1)) SWIG_fail;
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 (arg1)->HideCellEditControl();
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 Py_INCREF(Py_None); resultobj = Py_None;
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxGrid *arg1 = (wxGrid *) 0 ;
10913 PyObject * obj0 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 (arg1)->SaveEditControlValue();
10924
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 Py_INCREF(Py_None); resultobj = Py_None;
10929 return resultobj;
10930 fail:
10931 return NULL;
10932 }
10933
10934
10935 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
10936 PyObject *resultobj;
10937 wxGrid *arg1 = (wxGrid *) 0 ;
10938 int arg2 ;
10939 int arg3 ;
10940 wxGridCellCoords result;
10941 PyObject * obj0 = 0 ;
10942 PyObject * obj1 = 0 ;
10943 PyObject * obj2 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self",(char *) "x",(char *) "y", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 arg2 = (int)(SWIG_As_int(obj1));
10953 if (SWIG_arg_fail(2)) SWIG_fail;
10954 }
10955 {
10956 arg3 = (int)(SWIG_As_int(obj2));
10957 if (SWIG_arg_fail(3)) SWIG_fail;
10958 }
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 result = wxGrid_XYToCell(arg1,arg2,arg3);
10962
10963 wxPyEndAllowThreads(__tstate);
10964 if (PyErr_Occurred()) SWIG_fail;
10965 }
10966 {
10967 wxGridCellCoords * resultptr;
10968 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
10969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
10970 }
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxGrid *arg1 = (wxGrid *) 0 ;
10980 int arg2 ;
10981 int result;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "self",(char *) "y", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
10989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10990 if (SWIG_arg_fail(1)) SWIG_fail;
10991 {
10992 arg2 = (int)(SWIG_As_int(obj1));
10993 if (SWIG_arg_fail(2)) SWIG_fail;
10994 }
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 result = (int)(arg1)->YToRow(arg2);
10998
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = SWIG_From_int((int)(result));
11004 }
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj;
11013 wxGrid *arg1 = (wxGrid *) 0 ;
11014 int arg2 ;
11015 int result;
11016 PyObject * obj0 = 0 ;
11017 PyObject * obj1 = 0 ;
11018 char *kwnames[] = {
11019 (char *) "self",(char *) "x", NULL
11020 };
11021
11022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11024 if (SWIG_arg_fail(1)) SWIG_fail;
11025 {
11026 arg2 = (int)(SWIG_As_int(obj1));
11027 if (SWIG_arg_fail(2)) SWIG_fail;
11028 }
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 result = (int)(arg1)->XToCol(arg2);
11032
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 {
11037 resultobj = SWIG_From_int((int)(result));
11038 }
11039 return resultobj;
11040 fail:
11041 return NULL;
11042 }
11043
11044
11045 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj;
11047 wxGrid *arg1 = (wxGrid *) 0 ;
11048 int arg2 ;
11049 int result;
11050 PyObject * obj0 = 0 ;
11051 PyObject * obj1 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self",(char *) "y", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 arg2 = (int)(SWIG_As_int(obj1));
11061 if (SWIG_arg_fail(2)) SWIG_fail;
11062 }
11063 {
11064 PyThreadState* __tstate = wxPyBeginAllowThreads();
11065 result = (int)(arg1)->YToEdgeOfRow(arg2);
11066
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 resultobj = SWIG_From_int((int)(result));
11072 }
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj;
11081 wxGrid *arg1 = (wxGrid *) 0 ;
11082 int arg2 ;
11083 int result;
11084 PyObject * obj0 = 0 ;
11085 PyObject * obj1 = 0 ;
11086 char *kwnames[] = {
11087 (char *) "self",(char *) "x", NULL
11088 };
11089
11090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 {
11094 arg2 = (int)(SWIG_As_int(obj1));
11095 if (SWIG_arg_fail(2)) SWIG_fail;
11096 }
11097 {
11098 PyThreadState* __tstate = wxPyBeginAllowThreads();
11099 result = (int)(arg1)->XToEdgeOfCol(arg2);
11100
11101 wxPyEndAllowThreads(__tstate);
11102 if (PyErr_Occurred()) SWIG_fail;
11103 }
11104 {
11105 resultobj = SWIG_From_int((int)(result));
11106 }
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxGrid *arg1 = (wxGrid *) 0 ;
11116 int arg2 ;
11117 int arg3 ;
11118 wxRect result;
11119 PyObject * obj0 = 0 ;
11120 PyObject * obj1 = 0 ;
11121 PyObject * obj2 = 0 ;
11122 char *kwnames[] = {
11123 (char *) "self",(char *) "row",(char *) "col", NULL
11124 };
11125
11126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11128 if (SWIG_arg_fail(1)) SWIG_fail;
11129 {
11130 arg2 = (int)(SWIG_As_int(obj1));
11131 if (SWIG_arg_fail(2)) SWIG_fail;
11132 }
11133 {
11134 arg3 = (int)(SWIG_As_int(obj2));
11135 if (SWIG_arg_fail(3)) SWIG_fail;
11136 }
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 result = (arg1)->CellToRect(arg2,arg3);
11140
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 {
11145 wxRect * resultptr;
11146 resultptr = new wxRect((wxRect &)(result));
11147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxGrid *arg1 = (wxGrid *) 0 ;
11158 int result;
11159 PyObject * obj0 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (int)(arg1)->GetGridCursorRow();
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 resultobj = SWIG_From_int((int)(result));
11176 }
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11184 PyObject *resultobj;
11185 wxGrid *arg1 = (wxGrid *) 0 ;
11186 int result;
11187 PyObject * obj0 = 0 ;
11188 char *kwnames[] = {
11189 (char *) "self", NULL
11190 };
11191
11192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11194 if (SWIG_arg_fail(1)) SWIG_fail;
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 result = (int)(arg1)->GetGridCursorCol();
11198
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 {
11203 resultobj = SWIG_From_int((int)(result));
11204 }
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11212 PyObject *resultobj;
11213 wxGrid *arg1 = (wxGrid *) 0 ;
11214 int arg2 ;
11215 int arg3 ;
11216 bool arg4 = (bool) true ;
11217 bool result;
11218 PyObject * obj0 = 0 ;
11219 PyObject * obj1 = 0 ;
11220 PyObject * obj2 = 0 ;
11221 PyObject * obj3 = 0 ;
11222 char *kwnames[] = {
11223 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11224 };
11225
11226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11228 if (SWIG_arg_fail(1)) SWIG_fail;
11229 {
11230 arg2 = (int)(SWIG_As_int(obj1));
11231 if (SWIG_arg_fail(2)) SWIG_fail;
11232 }
11233 {
11234 arg3 = (int)(SWIG_As_int(obj2));
11235 if (SWIG_arg_fail(3)) SWIG_fail;
11236 }
11237 if (obj3) {
11238 {
11239 arg4 = (bool)(SWIG_As_bool(obj3));
11240 if (SWIG_arg_fail(4)) SWIG_fail;
11241 }
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11246
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 {
11251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11252 }
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj;
11261 wxGrid *arg1 = (wxGrid *) 0 ;
11262 int arg2 ;
11263 int arg3 ;
11264 PyObject * obj0 = 0 ;
11265 PyObject * obj1 = 0 ;
11266 PyObject * obj2 = 0 ;
11267 char *kwnames[] = {
11268 (char *) "self",(char *) "row",(char *) "col", NULL
11269 };
11270
11271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11273 if (SWIG_arg_fail(1)) SWIG_fail;
11274 {
11275 arg2 = (int)(SWIG_As_int(obj1));
11276 if (SWIG_arg_fail(2)) SWIG_fail;
11277 }
11278 {
11279 arg3 = (int)(SWIG_As_int(obj2));
11280 if (SWIG_arg_fail(3)) SWIG_fail;
11281 }
11282 {
11283 PyThreadState* __tstate = wxPyBeginAllowThreads();
11284 (arg1)->MakeCellVisible(arg2,arg3);
11285
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 Py_INCREF(Py_None); resultobj = Py_None;
11290 return resultobj;
11291 fail:
11292 return NULL;
11293 }
11294
11295
11296 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj;
11298 wxGrid *arg1 = (wxGrid *) 0 ;
11299 int arg2 ;
11300 int arg3 ;
11301 PyObject * obj0 = 0 ;
11302 PyObject * obj1 = 0 ;
11303 PyObject * obj2 = 0 ;
11304 char *kwnames[] = {
11305 (char *) "self",(char *) "row",(char *) "col", NULL
11306 };
11307
11308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11310 if (SWIG_arg_fail(1)) SWIG_fail;
11311 {
11312 arg2 = (int)(SWIG_As_int(obj1));
11313 if (SWIG_arg_fail(2)) SWIG_fail;
11314 }
11315 {
11316 arg3 = (int)(SWIG_As_int(obj2));
11317 if (SWIG_arg_fail(3)) SWIG_fail;
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 (arg1)->SetGridCursor(arg2,arg3);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 Py_INCREF(Py_None); resultobj = Py_None;
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj;
11335 wxGrid *arg1 = (wxGrid *) 0 ;
11336 bool arg2 ;
11337 bool result;
11338 PyObject * obj0 = 0 ;
11339 PyObject * obj1 = 0 ;
11340 char *kwnames[] = {
11341 (char *) "self",(char *) "expandSelection", NULL
11342 };
11343
11344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11346 if (SWIG_arg_fail(1)) SWIG_fail;
11347 {
11348 arg2 = (bool)(SWIG_As_bool(obj1));
11349 if (SWIG_arg_fail(2)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (bool)(arg1)->MoveCursorUp(arg2);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxGrid *arg1 = (wxGrid *) 0 ;
11370 bool arg2 ;
11371 bool result;
11372 PyObject * obj0 = 0 ;
11373 PyObject * obj1 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self",(char *) "expandSelection", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 arg2 = (bool)(SWIG_As_bool(obj1));
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 result = (bool)(arg1)->MoveCursorDown(arg2);
11388
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 {
11393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11402 PyObject *resultobj;
11403 wxGrid *arg1 = (wxGrid *) 0 ;
11404 bool arg2 ;
11405 bool result;
11406 PyObject * obj0 = 0 ;
11407 PyObject * obj1 = 0 ;
11408 char *kwnames[] = {
11409 (char *) "self",(char *) "expandSelection", NULL
11410 };
11411
11412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11414 if (SWIG_arg_fail(1)) SWIG_fail;
11415 {
11416 arg2 = (bool)(SWIG_As_bool(obj1));
11417 if (SWIG_arg_fail(2)) SWIG_fail;
11418 }
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 result = (bool)(arg1)->MoveCursorLeft(arg2);
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 {
11427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11428 }
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj;
11437 wxGrid *arg1 = (wxGrid *) 0 ;
11438 bool arg2 ;
11439 bool result;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 char *kwnames[] = {
11443 (char *) "self",(char *) "expandSelection", NULL
11444 };
11445
11446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11448 if (SWIG_arg_fail(1)) SWIG_fail;
11449 {
11450 arg2 = (bool)(SWIG_As_bool(obj1));
11451 if (SWIG_arg_fail(2)) SWIG_fail;
11452 }
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (bool)(arg1)->MoveCursorRight(arg2);
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 {
11461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11462 }
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11470 PyObject *resultobj;
11471 wxGrid *arg1 = (wxGrid *) 0 ;
11472 bool result;
11473 PyObject * obj0 = 0 ;
11474 char *kwnames[] = {
11475 (char *) "self", NULL
11476 };
11477
11478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11480 if (SWIG_arg_fail(1)) SWIG_fail;
11481 {
11482 PyThreadState* __tstate = wxPyBeginAllowThreads();
11483 result = (bool)(arg1)->MovePageDown();
11484
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11490 }
11491 return resultobj;
11492 fail:
11493 return NULL;
11494 }
11495
11496
11497 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11498 PyObject *resultobj;
11499 wxGrid *arg1 = (wxGrid *) 0 ;
11500 bool result;
11501 PyObject * obj0 = 0 ;
11502 char *kwnames[] = {
11503 (char *) "self", NULL
11504 };
11505
11506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11508 if (SWIG_arg_fail(1)) SWIG_fail;
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 result = (bool)(arg1)->MovePageUp();
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_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
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_MoveCursorUpBlock",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 = (bool)(SWIG_As_bool(obj1));
11541 if (SWIG_arg_fail(2)) SWIG_fail;
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (bool)(arg1)->MoveCursorUpBlock(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_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
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_MoveCursorDownBlock",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 = (bool)(SWIG_As_bool(obj1));
11575 if (SWIG_arg_fail(2)) SWIG_fail;
11576 }
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = (bool)(arg1)->MoveCursorDownBlock(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_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj;
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_MoveCursorLeftBlock",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 = (bool)(SWIG_As_bool(obj1));
11609 if (SWIG_arg_fail(2)) SWIG_fail;
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (bool)(arg1)->MoveCursorLeftBlock(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_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj;
11629 wxGrid *arg1 = (wxGrid *) 0 ;
11630 bool arg2 ;
11631 bool result;
11632 PyObject * obj0 = 0 ;
11633 PyObject * obj1 = 0 ;
11634 char *kwnames[] = {
11635 (char *) "self",(char *) "expandSelection", NULL
11636 };
11637
11638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 {
11642 arg2 = (bool)(SWIG_As_bool(obj1));
11643 if (SWIG_arg_fail(2)) SWIG_fail;
11644 }
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11648
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 {
11653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11654 }
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxGrid *arg1 = (wxGrid *) 0 ;
11664 int result;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (int)(arg1)->GetDefaultRowLabelSize();
11676
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 {
11681 resultobj = SWIG_From_int((int)(result));
11682 }
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj;
11691 wxGrid *arg1 = (wxGrid *) 0 ;
11692 int result;
11693 PyObject * obj0 = 0 ;
11694 char *kwnames[] = {
11695 (char *) "self", NULL
11696 };
11697
11698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11700 if (SWIG_arg_fail(1)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (int)(arg1)->GetRowLabelSize();
11704
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = SWIG_From_int((int)(result));
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj;
11719 wxGrid *arg1 = (wxGrid *) 0 ;
11720 int result;
11721 PyObject * obj0 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (int)(arg1)->GetDefaultColLabelSize();
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = SWIG_From_int((int)(result));
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj;
11747 wxGrid *arg1 = (wxGrid *) 0 ;
11748 int result;
11749 PyObject * obj0 = 0 ;
11750 char *kwnames[] = {
11751 (char *) "self", NULL
11752 };
11753
11754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11756 if (SWIG_arg_fail(1)) SWIG_fail;
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (int)(arg1)->GetColLabelSize();
11760
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 {
11765 resultobj = SWIG_From_int((int)(result));
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxGrid *arg1 = (wxGrid *) 0 ;
11776 wxColour result;
11777 PyObject * obj0 = 0 ;
11778 char *kwnames[] = {
11779 (char *) "self", NULL
11780 };
11781
11782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
11783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11784 if (SWIG_arg_fail(1)) SWIG_fail;
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (arg1)->GetLabelBackgroundColour();
11788
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 wxColour * resultptr;
11794 resultptr = new wxColour((wxColour &)(result));
11795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11796 }
11797 return resultobj;
11798 fail:
11799 return NULL;
11800 }
11801
11802
11803 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj;
11805 wxGrid *arg1 = (wxGrid *) 0 ;
11806 wxColour result;
11807 PyObject * obj0 = 0 ;
11808 char *kwnames[] = {
11809 (char *) "self", NULL
11810 };
11811
11812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
11813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11814 if (SWIG_arg_fail(1)) SWIG_fail;
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (arg1)->GetLabelTextColour();
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 wxColour * resultptr;
11824 resultptr = new wxColour((wxColour &)(result));
11825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11826 }
11827 return resultobj;
11828 fail:
11829 return NULL;
11830 }
11831
11832
11833 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
11834 PyObject *resultobj;
11835 wxGrid *arg1 = (wxGrid *) 0 ;
11836 wxFont result;
11837 PyObject * obj0 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (arg1)->GetLabelFont();
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 wxFont * resultptr;
11854 resultptr = new wxFont((wxFont &)(result));
11855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
11856 }
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11864 PyObject *resultobj;
11865 wxGrid *arg1 = (wxGrid *) 0 ;
11866 int *arg2 = (int *) 0 ;
11867 int *arg3 = (int *) 0 ;
11868 int temp2 ;
11869 int res2 = 0 ;
11870 int temp3 ;
11871 int res3 = 0 ;
11872 PyObject * obj0 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self", NULL
11875 };
11876
11877 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11878 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
11880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11881 if (SWIG_arg_fail(1)) SWIG_fail;
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 (arg1)->GetRowLabelAlignment(arg2,arg3);
11885
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 Py_INCREF(Py_None); resultobj = Py_None;
11890 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11891 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11892 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11893 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11894 return resultobj;
11895 fail:
11896 return NULL;
11897 }
11898
11899
11900 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11901 PyObject *resultobj;
11902 wxGrid *arg1 = (wxGrid *) 0 ;
11903 int *arg2 = (int *) 0 ;
11904 int *arg3 = (int *) 0 ;
11905 int temp2 ;
11906 int res2 = 0 ;
11907 int temp3 ;
11908 int res3 = 0 ;
11909 PyObject * obj0 = 0 ;
11910 char *kwnames[] = {
11911 (char *) "self", NULL
11912 };
11913
11914 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11915 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
11917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11918 if (SWIG_arg_fail(1)) SWIG_fail;
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 (arg1)->GetColLabelAlignment(arg2,arg3);
11922
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 Py_INCREF(Py_None); resultobj = Py_None;
11927 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11928 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11929 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11930 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxGrid *arg1 = (wxGrid *) 0 ;
11940 int result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (int)(arg1)->GetColLabelTextOrientation();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = SWIG_From_int((int)(result));
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxGrid *arg1 = (wxGrid *) 0 ;
11968 int arg2 ;
11969 wxString result;
11970 PyObject * obj0 = 0 ;
11971 PyObject * obj1 = 0 ;
11972 char *kwnames[] = {
11973 (char *) "self",(char *) "row", NULL
11974 };
11975
11976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
11977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11978 if (SWIG_arg_fail(1)) SWIG_fail;
11979 {
11980 arg2 = (int)(SWIG_As_int(obj1));
11981 if (SWIG_arg_fail(2)) SWIG_fail;
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (arg1)->GetRowLabelValue(arg2);
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 #if wxUSE_UNICODE
11992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11993 #else
11994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11995 #endif
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxGrid *arg1 = (wxGrid *) 0 ;
12006 int arg2 ;
12007 wxString result;
12008 PyObject * obj0 = 0 ;
12009 PyObject * obj1 = 0 ;
12010 char *kwnames[] = {
12011 (char *) "self",(char *) "col", NULL
12012 };
12013
12014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12016 if (SWIG_arg_fail(1)) SWIG_fail;
12017 {
12018 arg2 = (int)(SWIG_As_int(obj1));
12019 if (SWIG_arg_fail(2)) SWIG_fail;
12020 }
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (arg1)->GetColLabelValue(arg2);
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 #if wxUSE_UNICODE
12030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12031 #else
12032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12033 #endif
12034 }
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj;
12043 wxGrid *arg1 = (wxGrid *) 0 ;
12044 wxColour result;
12045 PyObject * obj0 = 0 ;
12046 char *kwnames[] = {
12047 (char *) "self", NULL
12048 };
12049
12050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12052 if (SWIG_arg_fail(1)) SWIG_fail;
12053 {
12054 PyThreadState* __tstate = wxPyBeginAllowThreads();
12055 result = (arg1)->GetGridLineColour();
12056
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 {
12061 wxColour * resultptr;
12062 resultptr = new wxColour((wxColour &)(result));
12063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxGrid *arg1 = (wxGrid *) 0 ;
12074 wxColour result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (arg1)->GetCellHighlightColour();
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 wxColour * resultptr;
12092 resultptr = new wxColour((wxColour &)(result));
12093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12094 }
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj;
12103 wxGrid *arg1 = (wxGrid *) 0 ;
12104 int result;
12105 PyObject * obj0 = 0 ;
12106 char *kwnames[] = {
12107 (char *) "self", NULL
12108 };
12109
12110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12112 if (SWIG_arg_fail(1)) SWIG_fail;
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 result = (int)(arg1)->GetCellHighlightPenWidth();
12116
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 {
12121 resultobj = SWIG_From_int((int)(result));
12122 }
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj;
12131 wxGrid *arg1 = (wxGrid *) 0 ;
12132 int result;
12133 PyObject * obj0 = 0 ;
12134 char *kwnames[] = {
12135 (char *) "self", NULL
12136 };
12137
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12140 if (SWIG_arg_fail(1)) SWIG_fail;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 result = (int)(arg1)->GetCellHighlightROPenWidth();
12144
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 {
12149 resultobj = SWIG_From_int((int)(result));
12150 }
12151 return resultobj;
12152 fail:
12153 return NULL;
12154 }
12155
12156
12157 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12158 PyObject *resultobj;
12159 wxGrid *arg1 = (wxGrid *) 0 ;
12160 int arg2 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char *kwnames[] = {
12164 (char *) "self",(char *) "width", NULL
12165 };
12166
12167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12169 if (SWIG_arg_fail(1)) SWIG_fail;
12170 {
12171 arg2 = (int)(SWIG_As_int(obj1));
12172 if (SWIG_arg_fail(2)) SWIG_fail;
12173 }
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 (arg1)->SetRowLabelSize(arg2);
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 Py_INCREF(Py_None); resultobj = Py_None;
12182 return resultobj;
12183 fail:
12184 return NULL;
12185 }
12186
12187
12188 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12189 PyObject *resultobj;
12190 wxGrid *arg1 = (wxGrid *) 0 ;
12191 int arg2 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self",(char *) "height", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 arg2 = (int)(SWIG_As_int(obj1));
12203 if (SWIG_arg_fail(2)) SWIG_fail;
12204 }
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 (arg1)->SetColLabelSize(arg2);
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 Py_INCREF(Py_None); resultobj = Py_None;
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxGrid *arg1 = (wxGrid *) 0 ;
12222 wxColour *arg2 = 0 ;
12223 wxColour temp2 ;
12224 PyObject * obj0 = 0 ;
12225 PyObject * obj1 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self","arg2", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 arg2 = &temp2;
12235 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12236 }
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12240
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 Py_INCREF(Py_None); resultobj = Py_None;
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj;
12253 wxGrid *arg1 = (wxGrid *) 0 ;
12254 wxColour *arg2 = 0 ;
12255 wxColour temp2 ;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self","arg2", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 arg2 = &temp2;
12267 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12268 }
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
12272
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 Py_INCREF(Py_None); resultobj = Py_None;
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Grid_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxGrid *arg1 = (wxGrid *) 0 ;
12286 wxFont *arg2 = 0 ;
12287 PyObject * obj0 = 0 ;
12288 PyObject * obj1 = 0 ;
12289 char *kwnames[] = {
12290 (char *) "self","arg2", NULL
12291 };
12292
12293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12295 if (SWIG_arg_fail(1)) SWIG_fail;
12296 {
12297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(2)) SWIG_fail;
12299 if (arg2 == NULL) {
12300 SWIG_null_ref("wxFont");
12301 }
12302 if (SWIG_arg_fail(2)) SWIG_fail;
12303 }
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 (arg1)->SetLabelFont((wxFont const &)*arg2);
12307
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 Py_INCREF(Py_None); resultobj = Py_None;
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12319 PyObject *resultobj;
12320 wxGrid *arg1 = (wxGrid *) 0 ;
12321 int arg2 ;
12322 int arg3 ;
12323 PyObject * obj0 = 0 ;
12324 PyObject * obj1 = 0 ;
12325 PyObject * obj2 = 0 ;
12326 char *kwnames[] = {
12327 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12328 };
12329
12330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12332 if (SWIG_arg_fail(1)) SWIG_fail;
12333 {
12334 arg2 = (int)(SWIG_As_int(obj1));
12335 if (SWIG_arg_fail(2)) SWIG_fail;
12336 }
12337 {
12338 arg3 = (int)(SWIG_As_int(obj2));
12339 if (SWIG_arg_fail(3)) SWIG_fail;
12340 }
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 (arg1)->SetRowLabelAlignment(arg2,arg3);
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 Py_INCREF(Py_None); resultobj = Py_None;
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj;
12357 wxGrid *arg1 = (wxGrid *) 0 ;
12358 int arg2 ;
12359 int arg3 ;
12360 PyObject * obj0 = 0 ;
12361 PyObject * obj1 = 0 ;
12362 PyObject * obj2 = 0 ;
12363 char *kwnames[] = {
12364 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12365 };
12366
12367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12369 if (SWIG_arg_fail(1)) SWIG_fail;
12370 {
12371 arg2 = (int)(SWIG_As_int(obj1));
12372 if (SWIG_arg_fail(2)) SWIG_fail;
12373 }
12374 {
12375 arg3 = (int)(SWIG_As_int(obj2));
12376 if (SWIG_arg_fail(3)) SWIG_fail;
12377 }
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 (arg1)->SetColLabelAlignment(arg2,arg3);
12381
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 Py_INCREF(Py_None); resultobj = Py_None;
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12393 PyObject *resultobj;
12394 wxGrid *arg1 = (wxGrid *) 0 ;
12395 int arg2 ;
12396 PyObject * obj0 = 0 ;
12397 PyObject * obj1 = 0 ;
12398 char *kwnames[] = {
12399 (char *) "self",(char *) "textOrientation", NULL
12400 };
12401
12402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12404 if (SWIG_arg_fail(1)) SWIG_fail;
12405 {
12406 arg2 = (int)(SWIG_As_int(obj1));
12407 if (SWIG_arg_fail(2)) SWIG_fail;
12408 }
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 (arg1)->SetColLabelTextOrientation(arg2);
12412
12413 wxPyEndAllowThreads(__tstate);
12414 if (PyErr_Occurred()) SWIG_fail;
12415 }
12416 Py_INCREF(Py_None); resultobj = Py_None;
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj;
12425 wxGrid *arg1 = (wxGrid *) 0 ;
12426 int arg2 ;
12427 wxString *arg3 = 0 ;
12428 bool temp3 = false ;
12429 PyObject * obj0 = 0 ;
12430 PyObject * obj1 = 0 ;
12431 PyObject * obj2 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self",(char *) "row","arg3", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 arg2 = (int)(SWIG_As_int(obj1));
12441 if (SWIG_arg_fail(2)) SWIG_fail;
12442 }
12443 {
12444 arg3 = wxString_in_helper(obj2);
12445 if (arg3 == NULL) SWIG_fail;
12446 temp3 = true;
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12451
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 Py_INCREF(Py_None); resultobj = Py_None;
12456 {
12457 if (temp3)
12458 delete arg3;
12459 }
12460 return resultobj;
12461 fail:
12462 {
12463 if (temp3)
12464 delete arg3;
12465 }
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxGrid *arg1 = (wxGrid *) 0 ;
12473 int arg2 ;
12474 wxString *arg3 = 0 ;
12475 bool temp3 = false ;
12476 PyObject * obj0 = 0 ;
12477 PyObject * obj1 = 0 ;
12478 PyObject * obj2 = 0 ;
12479 char *kwnames[] = {
12480 (char *) "self",(char *) "col","arg3", NULL
12481 };
12482
12483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12485 if (SWIG_arg_fail(1)) SWIG_fail;
12486 {
12487 arg2 = (int)(SWIG_As_int(obj1));
12488 if (SWIG_arg_fail(2)) SWIG_fail;
12489 }
12490 {
12491 arg3 = wxString_in_helper(obj2);
12492 if (arg3 == NULL) SWIG_fail;
12493 temp3 = true;
12494 }
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12498
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 Py_INCREF(Py_None); resultobj = Py_None;
12503 {
12504 if (temp3)
12505 delete arg3;
12506 }
12507 return resultobj;
12508 fail:
12509 {
12510 if (temp3)
12511 delete arg3;
12512 }
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj;
12519 wxGrid *arg1 = (wxGrid *) 0 ;
12520 wxColour *arg2 = 0 ;
12521 wxColour temp2 ;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self","arg2", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 arg2 = &temp2;
12533 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12534 }
12535 {
12536 PyThreadState* __tstate = wxPyBeginAllowThreads();
12537 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12538
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 Py_INCREF(Py_None); resultobj = Py_None;
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj;
12551 wxGrid *arg1 = (wxGrid *) 0 ;
12552 wxColour *arg2 = 0 ;
12553 wxColour temp2 ;
12554 PyObject * obj0 = 0 ;
12555 PyObject * obj1 = 0 ;
12556 char *kwnames[] = {
12557 (char *) "self","arg2", NULL
12558 };
12559
12560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",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 = &temp2;
12565 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12566 }
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 (arg1)->SetCellHighlightColour((wxColour const &)*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_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj;
12583 wxGrid *arg1 = (wxGrid *) 0 ;
12584 int arg2 ;
12585 PyObject * obj0 = 0 ;
12586 PyObject * obj1 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self",(char *) "width", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 arg2 = (int)(SWIG_As_int(obj1));
12596 if (SWIG_arg_fail(2)) SWIG_fail;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 (arg1)->SetCellHighlightPenWidth(arg2);
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 Py_INCREF(Py_None); resultobj = Py_None;
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxGrid *arg1 = (wxGrid *) 0 ;
12615 int arg2 ;
12616 PyObject * obj0 = 0 ;
12617 PyObject * obj1 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self",(char *) "width", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 arg2 = (int)(SWIG_As_int(obj1));
12627 if (SWIG_arg_fail(2)) SWIG_fail;
12628 }
12629 {
12630 PyThreadState* __tstate = wxPyBeginAllowThreads();
12631 (arg1)->SetCellHighlightROPenWidth(arg2);
12632
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 Py_INCREF(Py_None); resultobj = Py_None;
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj;
12645 wxGrid *arg1 = (wxGrid *) 0 ;
12646 bool arg2 = (bool) true ;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 char *kwnames[] = {
12650 (char *) "self",(char *) "enable", NULL
12651 };
12652
12653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12655 if (SWIG_arg_fail(1)) SWIG_fail;
12656 if (obj1) {
12657 {
12658 arg2 = (bool)(SWIG_As_bool(obj1));
12659 if (SWIG_arg_fail(2)) SWIG_fail;
12660 }
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 (arg1)->EnableDragRowSize(arg2);
12665
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 Py_INCREF(Py_None); resultobj = Py_None;
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_Grid_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxGrid *arg1 = (wxGrid *) 0 ;
12679 PyObject * obj0 = 0 ;
12680 char *kwnames[] = {
12681 (char *) "self", NULL
12682 };
12683
12684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12686 if (SWIG_arg_fail(1)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 (arg1)->DisableDragRowSize();
12690
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 Py_INCREF(Py_None); resultobj = Py_None;
12695 return resultobj;
12696 fail:
12697 return NULL;
12698 }
12699
12700
12701 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12702 PyObject *resultobj;
12703 wxGrid *arg1 = (wxGrid *) 0 ;
12704 bool result;
12705 PyObject * obj0 = 0 ;
12706 char *kwnames[] = {
12707 (char *) "self", NULL
12708 };
12709
12710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12712 if (SWIG_arg_fail(1)) SWIG_fail;
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 result = (bool)(arg1)->CanDragRowSize();
12716
12717 wxPyEndAllowThreads(__tstate);
12718 if (PyErr_Occurred()) SWIG_fail;
12719 }
12720 {
12721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12722 }
12723 return resultobj;
12724 fail:
12725 return NULL;
12726 }
12727
12728
12729 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12730 PyObject *resultobj;
12731 wxGrid *arg1 = (wxGrid *) 0 ;
12732 bool arg2 = (bool) true ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "self",(char *) "enable", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12741 if (SWIG_arg_fail(1)) SWIG_fail;
12742 if (obj1) {
12743 {
12744 arg2 = (bool)(SWIG_As_bool(obj1));
12745 if (SWIG_arg_fail(2)) SWIG_fail;
12746 }
12747 }
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 (arg1)->EnableDragColSize(arg2);
12751
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 Py_INCREF(Py_None); resultobj = Py_None;
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj;
12764 wxGrid *arg1 = (wxGrid *) 0 ;
12765 PyObject * obj0 = 0 ;
12766 char *kwnames[] = {
12767 (char *) "self", NULL
12768 };
12769
12770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12772 if (SWIG_arg_fail(1)) SWIG_fail;
12773 {
12774 PyThreadState* __tstate = wxPyBeginAllowThreads();
12775 (arg1)->DisableDragColSize();
12776
12777 wxPyEndAllowThreads(__tstate);
12778 if (PyErr_Occurred()) SWIG_fail;
12779 }
12780 Py_INCREF(Py_None); resultobj = Py_None;
12781 return resultobj;
12782 fail:
12783 return NULL;
12784 }
12785
12786
12787 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj;
12789 wxGrid *arg1 = (wxGrid *) 0 ;
12790 bool result;
12791 PyObject * obj0 = 0 ;
12792 char *kwnames[] = {
12793 (char *) "self", NULL
12794 };
12795
12796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
12797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (bool)(arg1)->CanDragColSize();
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 {
12807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12808 }
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj;
12817 wxGrid *arg1 = (wxGrid *) 0 ;
12818 bool arg2 = (bool) true ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 char *kwnames[] = {
12822 (char *) "self",(char *) "enable", NULL
12823 };
12824
12825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
12826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12827 if (SWIG_arg_fail(1)) SWIG_fail;
12828 if (obj1) {
12829 {
12830 arg2 = (bool)(SWIG_As_bool(obj1));
12831 if (SWIG_arg_fail(2)) SWIG_fail;
12832 }
12833 }
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 (arg1)->EnableDragGridSize(arg2);
12837
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 Py_INCREF(Py_None); resultobj = Py_None;
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj;
12850 wxGrid *arg1 = (wxGrid *) 0 ;
12851 PyObject * obj0 = 0 ;
12852 char *kwnames[] = {
12853 (char *) "self", NULL
12854 };
12855
12856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
12857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12858 if (SWIG_arg_fail(1)) SWIG_fail;
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 (arg1)->DisableDragGridSize();
12862
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 Py_INCREF(Py_None); resultobj = Py_None;
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12874 PyObject *resultobj;
12875 wxGrid *arg1 = (wxGrid *) 0 ;
12876 bool result;
12877 PyObject * obj0 = 0 ;
12878 char *kwnames[] = {
12879 (char *) "self", NULL
12880 };
12881
12882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
12883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12884 if (SWIG_arg_fail(1)) SWIG_fail;
12885 {
12886 PyThreadState* __tstate = wxPyBeginAllowThreads();
12887 result = (bool)(arg1)->CanDragGridSize();
12888
12889 wxPyEndAllowThreads(__tstate);
12890 if (PyErr_Occurred()) SWIG_fail;
12891 }
12892 {
12893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12894 }
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxGrid *arg1 = (wxGrid *) 0 ;
12904 bool arg2 = (bool) true ;
12905 PyObject * obj0 = 0 ;
12906 PyObject * obj1 = 0 ;
12907 char *kwnames[] = {
12908 (char *) "self",(char *) "enable", NULL
12909 };
12910
12911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
12912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12913 if (SWIG_arg_fail(1)) SWIG_fail;
12914 if (obj1) {
12915 {
12916 arg2 = (bool)(SWIG_As_bool(obj1));
12917 if (SWIG_arg_fail(2)) SWIG_fail;
12918 }
12919 }
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 (arg1)->EnableDragCell(arg2);
12923
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 Py_INCREF(Py_None); resultobj = Py_None;
12928 return resultobj;
12929 fail:
12930 return NULL;
12931 }
12932
12933
12934 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12935 PyObject *resultobj;
12936 wxGrid *arg1 = (wxGrid *) 0 ;
12937 PyObject * obj0 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "self", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
12943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12944 if (SWIG_arg_fail(1)) SWIG_fail;
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 (arg1)->DisableDragCell();
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 Py_INCREF(Py_None); resultobj = Py_None;
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj;
12961 wxGrid *arg1 = (wxGrid *) 0 ;
12962 bool result;
12963 PyObject * obj0 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = (bool)(arg1)->CanDragCell();
12974
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12980 }
12981 return resultobj;
12982 fail:
12983 return NULL;
12984 }
12985
12986
12987 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
12988 PyObject *resultobj;
12989 wxGrid *arg1 = (wxGrid *) 0 ;
12990 int arg2 ;
12991 int arg3 ;
12992 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
12993 PyObject * obj0 = 0 ;
12994 PyObject * obj1 = 0 ;
12995 PyObject * obj2 = 0 ;
12996 PyObject * obj3 = 0 ;
12997 char *kwnames[] = {
12998 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
12999 };
13000
13001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13003 if (SWIG_arg_fail(1)) SWIG_fail;
13004 {
13005 arg2 = (int)(SWIG_As_int(obj1));
13006 if (SWIG_arg_fail(2)) SWIG_fail;
13007 }
13008 {
13009 arg3 = (int)(SWIG_As_int(obj2));
13010 if (SWIG_arg_fail(3)) SWIG_fail;
13011 }
13012 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(4)) SWIG_fail;
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 (arg1)->SetAttr(arg2,arg3,arg4);
13017
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 Py_INCREF(Py_None); resultobj = Py_None;
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13029 PyObject *resultobj;
13030 wxGrid *arg1 = (wxGrid *) 0 ;
13031 int arg2 ;
13032 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13033 PyObject * obj0 = 0 ;
13034 PyObject * obj1 = 0 ;
13035 PyObject * obj2 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self",(char *) "row",(char *) "attr", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
13045 if (SWIG_arg_fail(2)) SWIG_fail;
13046 }
13047 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13048 if (SWIG_arg_fail(3)) SWIG_fail;
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 (arg1)->SetRowAttr(arg2,arg3);
13052
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 Py_INCREF(Py_None); resultobj = Py_None;
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj;
13065 wxGrid *arg1 = (wxGrid *) 0 ;
13066 int arg2 ;
13067 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 char *kwnames[] = {
13072 (char *) "self",(char *) "col",(char *) "attr", NULL
13073 };
13074
13075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13077 if (SWIG_arg_fail(1)) SWIG_fail;
13078 {
13079 arg2 = (int)(SWIG_As_int(obj1));
13080 if (SWIG_arg_fail(2)) SWIG_fail;
13081 }
13082 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13083 if (SWIG_arg_fail(3)) SWIG_fail;
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 (arg1)->SetColAttr(arg2,arg3);
13087
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 Py_INCREF(Py_None); resultobj = Py_None;
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13099 PyObject *resultobj;
13100 wxGrid *arg1 = (wxGrid *) 0 ;
13101 int arg2 ;
13102 int arg3 ;
13103 wxGridCellAttr *result;
13104 PyObject * obj0 = 0 ;
13105 PyObject * obj1 = 0 ;
13106 PyObject * obj2 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self",(char *) "row",(char *) "col", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 {
13115 arg2 = (int)(SWIG_As_int(obj1));
13116 if (SWIG_arg_fail(2)) SWIG_fail;
13117 }
13118 {
13119 arg3 = (int)(SWIG_As_int(obj2));
13120 if (SWIG_arg_fail(3)) SWIG_fail;
13121 }
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13125
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 {
13130 resultobj = wxPyMake_wxGridCellAttr(result, 0);
13131 }
13132 return resultobj;
13133 fail:
13134 return NULL;
13135 }
13136
13137
13138 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13139 PyObject *resultobj;
13140 wxGrid *arg1 = (wxGrid *) 0 ;
13141 int arg2 ;
13142 PyObject * obj0 = 0 ;
13143 PyObject * obj1 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self",(char *) "col", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 {
13152 arg2 = (int)(SWIG_As_int(obj1));
13153 if (SWIG_arg_fail(2)) SWIG_fail;
13154 }
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 (arg1)->SetColFormatBool(arg2);
13158
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 Py_INCREF(Py_None); resultobj = Py_None;
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj;
13171 wxGrid *arg1 = (wxGrid *) 0 ;
13172 int arg2 ;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 char *kwnames[] = {
13176 (char *) "self",(char *) "col", NULL
13177 };
13178
13179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13181 if (SWIG_arg_fail(1)) SWIG_fail;
13182 {
13183 arg2 = (int)(SWIG_As_int(obj1));
13184 if (SWIG_arg_fail(2)) SWIG_fail;
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 (arg1)->SetColFormatNumber(arg2);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxGrid *arg1 = (wxGrid *) 0 ;
13203 int arg2 ;
13204 int arg3 = (int) -1 ;
13205 int arg4 = (int) -1 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 PyObject * obj3 = 0 ;
13210 char *kwnames[] = {
13211 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13212 };
13213
13214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13216 if (SWIG_arg_fail(1)) SWIG_fail;
13217 {
13218 arg2 = (int)(SWIG_As_int(obj1));
13219 if (SWIG_arg_fail(2)) SWIG_fail;
13220 }
13221 if (obj2) {
13222 {
13223 arg3 = (int)(SWIG_As_int(obj2));
13224 if (SWIG_arg_fail(3)) SWIG_fail;
13225 }
13226 }
13227 if (obj3) {
13228 {
13229 arg4 = (int)(SWIG_As_int(obj3));
13230 if (SWIG_arg_fail(4)) SWIG_fail;
13231 }
13232 }
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13236
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 Py_INCREF(Py_None); resultobj = Py_None;
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj;
13249 wxGrid *arg1 = (wxGrid *) 0 ;
13250 int arg2 ;
13251 wxString *arg3 = 0 ;
13252 bool temp3 = false ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char *kwnames[] = {
13257 (char *) "self",(char *) "col",(char *) "typeName", NULL
13258 };
13259
13260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13262 if (SWIG_arg_fail(1)) SWIG_fail;
13263 {
13264 arg2 = (int)(SWIG_As_int(obj1));
13265 if (SWIG_arg_fail(2)) SWIG_fail;
13266 }
13267 {
13268 arg3 = wxString_in_helper(obj2);
13269 if (arg3 == NULL) SWIG_fail;
13270 temp3 = true;
13271 }
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13275
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 Py_INCREF(Py_None); resultobj = Py_None;
13280 {
13281 if (temp3)
13282 delete arg3;
13283 }
13284 return resultobj;
13285 fail:
13286 {
13287 if (temp3)
13288 delete arg3;
13289 }
13290 return NULL;
13291 }
13292
13293
13294 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj;
13296 wxGrid *arg1 = (wxGrid *) 0 ;
13297 bool arg2 = (bool) true ;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 char *kwnames[] = {
13301 (char *) "self",(char *) "enable", NULL
13302 };
13303
13304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13306 if (SWIG_arg_fail(1)) SWIG_fail;
13307 if (obj1) {
13308 {
13309 arg2 = (bool)(SWIG_As_bool(obj1));
13310 if (SWIG_arg_fail(2)) SWIG_fail;
13311 }
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 (arg1)->EnableGridLines(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_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj;
13329 wxGrid *arg1 = (wxGrid *) 0 ;
13330 bool result;
13331 PyObject * obj0 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 {
13340 PyThreadState* __tstate = wxPyBeginAllowThreads();
13341 result = (bool)(arg1)->GridLinesEnabled();
13342
13343 wxPyEndAllowThreads(__tstate);
13344 if (PyErr_Occurred()) SWIG_fail;
13345 }
13346 {
13347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13348 }
13349 return resultobj;
13350 fail:
13351 return NULL;
13352 }
13353
13354
13355 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13356 PyObject *resultobj;
13357 wxGrid *arg1 = (wxGrid *) 0 ;
13358 int result;
13359 PyObject * obj0 = 0 ;
13360 char *kwnames[] = {
13361 (char *) "self", NULL
13362 };
13363
13364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13366 if (SWIG_arg_fail(1)) SWIG_fail;
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = (int)(arg1)->GetDefaultRowSize();
13370
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 {
13375 resultobj = SWIG_From_int((int)(result));
13376 }
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13384 PyObject *resultobj;
13385 wxGrid *arg1 = (wxGrid *) 0 ;
13386 int arg2 ;
13387 int result;
13388 PyObject * obj0 = 0 ;
13389 PyObject * obj1 = 0 ;
13390 char *kwnames[] = {
13391 (char *) "self",(char *) "row", NULL
13392 };
13393
13394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13396 if (SWIG_arg_fail(1)) SWIG_fail;
13397 {
13398 arg2 = (int)(SWIG_As_int(obj1));
13399 if (SWIG_arg_fail(2)) SWIG_fail;
13400 }
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = (int)(arg1)->GetRowSize(arg2);
13404
13405 wxPyEndAllowThreads(__tstate);
13406 if (PyErr_Occurred()) SWIG_fail;
13407 }
13408 {
13409 resultobj = SWIG_From_int((int)(result));
13410 }
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj;
13419 wxGrid *arg1 = (wxGrid *) 0 ;
13420 int result;
13421 PyObject * obj0 = 0 ;
13422 char *kwnames[] = {
13423 (char *) "self", NULL
13424 };
13425
13426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13428 if (SWIG_arg_fail(1)) SWIG_fail;
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (int)(arg1)->GetDefaultColSize();
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 {
13437 resultobj = SWIG_From_int((int)(result));
13438 }
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj;
13447 wxGrid *arg1 = (wxGrid *) 0 ;
13448 int arg2 ;
13449 int result;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 char *kwnames[] = {
13453 (char *) "self",(char *) "col", NULL
13454 };
13455
13456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13458 if (SWIG_arg_fail(1)) SWIG_fail;
13459 {
13460 arg2 = (int)(SWIG_As_int(obj1));
13461 if (SWIG_arg_fail(2)) SWIG_fail;
13462 }
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 result = (int)(arg1)->GetColSize(arg2);
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 {
13471 resultobj = SWIG_From_int((int)(result));
13472 }
13473 return resultobj;
13474 fail:
13475 return NULL;
13476 }
13477
13478
13479 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj;
13481 wxGrid *arg1 = (wxGrid *) 0 ;
13482 wxColour result;
13483 PyObject * obj0 = 0 ;
13484 char *kwnames[] = {
13485 (char *) "self", NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13490 if (SWIG_arg_fail(1)) SWIG_fail;
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (arg1)->GetDefaultCellBackgroundColour();
13494
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 {
13499 wxColour * resultptr;
13500 resultptr = new wxColour((wxColour &)(result));
13501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13502 }
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj;
13511 wxGrid *arg1 = (wxGrid *) 0 ;
13512 int arg2 ;
13513 int arg3 ;
13514 wxColour result;
13515 PyObject * obj0 = 0 ;
13516 PyObject * obj1 = 0 ;
13517 PyObject * obj2 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "row",(char *) "col", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
13527 if (SWIG_arg_fail(2)) SWIG_fail;
13528 }
13529 {
13530 arg3 = (int)(SWIG_As_int(obj2));
13531 if (SWIG_arg_fail(3)) SWIG_fail;
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13536
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 {
13541 wxColour * resultptr;
13542 resultptr = new wxColour((wxColour &)(result));
13543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13544 }
13545 return resultobj;
13546 fail:
13547 return NULL;
13548 }
13549
13550
13551 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13552 PyObject *resultobj;
13553 wxGrid *arg1 = (wxGrid *) 0 ;
13554 wxColour result;
13555 PyObject * obj0 = 0 ;
13556 char *kwnames[] = {
13557 (char *) "self", NULL
13558 };
13559
13560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13562 if (SWIG_arg_fail(1)) SWIG_fail;
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 result = (arg1)->GetDefaultCellTextColour();
13566
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 {
13571 wxColour * resultptr;
13572 resultptr = new wxColour((wxColour &)(result));
13573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13574 }
13575 return resultobj;
13576 fail:
13577 return NULL;
13578 }
13579
13580
13581 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13582 PyObject *resultobj;
13583 wxGrid *arg1 = (wxGrid *) 0 ;
13584 int arg2 ;
13585 int arg3 ;
13586 wxColour result;
13587 PyObject * obj0 = 0 ;
13588 PyObject * obj1 = 0 ;
13589 PyObject * obj2 = 0 ;
13590 char *kwnames[] = {
13591 (char *) "self",(char *) "row",(char *) "col", NULL
13592 };
13593
13594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13596 if (SWIG_arg_fail(1)) SWIG_fail;
13597 {
13598 arg2 = (int)(SWIG_As_int(obj1));
13599 if (SWIG_arg_fail(2)) SWIG_fail;
13600 }
13601 {
13602 arg3 = (int)(SWIG_As_int(obj2));
13603 if (SWIG_arg_fail(3)) SWIG_fail;
13604 }
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (arg1)->GetCellTextColour(arg2,arg3);
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 {
13613 wxColour * resultptr;
13614 resultptr = new wxColour((wxColour &)(result));
13615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13616 }
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13624 PyObject *resultobj;
13625 wxGrid *arg1 = (wxGrid *) 0 ;
13626 wxFont result;
13627 PyObject * obj0 = 0 ;
13628 char *kwnames[] = {
13629 (char *) "self", NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13634 if (SWIG_arg_fail(1)) SWIG_fail;
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (arg1)->GetDefaultCellFont();
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 {
13643 wxFont * resultptr;
13644 resultptr = new wxFont((wxFont &)(result));
13645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13646 }
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxGrid *arg1 = (wxGrid *) 0 ;
13656 int arg2 ;
13657 int arg3 ;
13658 wxFont result;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 PyObject * obj2 = 0 ;
13662 char *kwnames[] = {
13663 (char *) "self",(char *) "row",(char *) "col", NULL
13664 };
13665
13666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13668 if (SWIG_arg_fail(1)) SWIG_fail;
13669 {
13670 arg2 = (int)(SWIG_As_int(obj1));
13671 if (SWIG_arg_fail(2)) SWIG_fail;
13672 }
13673 {
13674 arg3 = (int)(SWIG_As_int(obj2));
13675 if (SWIG_arg_fail(3)) SWIG_fail;
13676 }
13677 {
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (arg1)->GetCellFont(arg2,arg3);
13680
13681 wxPyEndAllowThreads(__tstate);
13682 if (PyErr_Occurred()) SWIG_fail;
13683 }
13684 {
13685 wxFont * resultptr;
13686 resultptr = new wxFont((wxFont &)(result));
13687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13688 }
13689 return resultobj;
13690 fail:
13691 return NULL;
13692 }
13693
13694
13695 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13696 PyObject *resultobj;
13697 wxGrid *arg1 = (wxGrid *) 0 ;
13698 int *arg2 = (int *) 0 ;
13699 int *arg3 = (int *) 0 ;
13700 int temp2 ;
13701 int res2 = 0 ;
13702 int temp3 ;
13703 int res3 = 0 ;
13704 PyObject * obj0 = 0 ;
13705 char *kwnames[] = {
13706 (char *) "self", NULL
13707 };
13708
13709 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13710 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13713 if (SWIG_arg_fail(1)) SWIG_fail;
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13717
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 Py_INCREF(Py_None); resultobj = Py_None;
13722 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13723 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13724 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13725 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj;
13734 wxGrid *arg1 = (wxGrid *) 0 ;
13735 int arg2 ;
13736 int arg3 ;
13737 int *arg4 = (int *) 0 ;
13738 int *arg5 = (int *) 0 ;
13739 int temp4 ;
13740 int res4 = 0 ;
13741 int temp5 ;
13742 int res5 = 0 ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 char *kwnames[] = {
13747 (char *) "self",(char *) "row",(char *) "col", NULL
13748 };
13749
13750 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13751 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",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 = (int)(SWIG_As_int(obj1));
13757 if (SWIG_arg_fail(2)) SWIG_fail;
13758 }
13759 {
13760 arg3 = (int)(SWIG_As_int(obj2));
13761 if (SWIG_arg_fail(3)) SWIG_fail;
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13766
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 Py_INCREF(Py_None); resultobj = Py_None;
13771 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13772 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13773 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13774 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj;
13783 wxGrid *arg1 = (wxGrid *) 0 ;
13784 bool result;
13785 PyObject * obj0 = 0 ;
13786 char *kwnames[] = {
13787 (char *) "self", NULL
13788 };
13789
13790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",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 = (bool)(arg1)->GetDefaultCellOverflow();
13796
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 {
13801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13802 }
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj;
13811 wxGrid *arg1 = (wxGrid *) 0 ;
13812 int arg2 ;
13813 int arg3 ;
13814 bool result;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 char *kwnames[] = {
13819 (char *) "self",(char *) "row",(char *) "col", NULL
13820 };
13821
13822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
13823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13824 if (SWIG_arg_fail(1)) SWIG_fail;
13825 {
13826 arg2 = (int)(SWIG_As_int(obj1));
13827 if (SWIG_arg_fail(2)) SWIG_fail;
13828 }
13829 {
13830 arg3 = (int)(SWIG_As_int(obj2));
13831 if (SWIG_arg_fail(3)) SWIG_fail;
13832 }
13833 {
13834 PyThreadState* __tstate = wxPyBeginAllowThreads();
13835 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
13836
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 {
13841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13842 }
13843 return resultobj;
13844 fail:
13845 return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxGrid *arg1 = (wxGrid *) 0 ;
13852 int arg2 ;
13853 int arg3 ;
13854 int *arg4 = (int *) 0 ;
13855 int *arg5 = (int *) 0 ;
13856 int temp4 ;
13857 int res4 = 0 ;
13858 int temp5 ;
13859 int res5 = 0 ;
13860 PyObject * obj0 = 0 ;
13861 PyObject * obj1 = 0 ;
13862 PyObject * obj2 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self",(char *) "row",(char *) "col", NULL
13865 };
13866
13867 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13868 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
13874 if (SWIG_arg_fail(2)) SWIG_fail;
13875 }
13876 {
13877 arg3 = (int)(SWIG_As_int(obj2));
13878 if (SWIG_arg_fail(3)) SWIG_fail;
13879 }
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
13883
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 Py_INCREF(Py_None); resultobj = Py_None;
13888 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13889 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13890 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13891 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13892 return resultobj;
13893 fail:
13894 return NULL;
13895 }
13896
13897
13898 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13899 PyObject *resultobj;
13900 wxGrid *arg1 = (wxGrid *) 0 ;
13901 int arg2 ;
13902 bool arg3 = (bool) false ;
13903 PyObject * obj0 = 0 ;
13904 PyObject * obj1 = 0 ;
13905 PyObject * obj2 = 0 ;
13906 char *kwnames[] = {
13907 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
13908 };
13909
13910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",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 = (int)(SWIG_As_int(obj1));
13915 if (SWIG_arg_fail(2)) SWIG_fail;
13916 }
13917 if (obj2) {
13918 {
13919 arg3 = (bool)(SWIG_As_bool(obj2));
13920 if (SWIG_arg_fail(3)) SWIG_fail;
13921 }
13922 }
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 (arg1)->SetDefaultRowSize(arg2,arg3);
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 Py_INCREF(Py_None); resultobj = Py_None;
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj;
13939 wxGrid *arg1 = (wxGrid *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 PyObject * obj0 = 0 ;
13943 PyObject * obj1 = 0 ;
13944 PyObject * obj2 = 0 ;
13945 char *kwnames[] = {
13946 (char *) "self",(char *) "row",(char *) "height", NULL
13947 };
13948
13949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13951 if (SWIG_arg_fail(1)) SWIG_fail;
13952 {
13953 arg2 = (int)(SWIG_As_int(obj1));
13954 if (SWIG_arg_fail(2)) SWIG_fail;
13955 }
13956 {
13957 arg3 = (int)(SWIG_As_int(obj2));
13958 if (SWIG_arg_fail(3)) SWIG_fail;
13959 }
13960 {
13961 PyThreadState* __tstate = wxPyBeginAllowThreads();
13962 (arg1)->SetRowSize(arg2,arg3);
13963
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 Py_INCREF(Py_None); resultobj = Py_None;
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxGrid *arg1 = (wxGrid *) 0 ;
13977 int arg2 ;
13978 bool arg3 = (bool) false ;
13979 PyObject * obj0 = 0 ;
13980 PyObject * obj1 = 0 ;
13981 PyObject * obj2 = 0 ;
13982 char *kwnames[] = {
13983 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
13984 };
13985
13986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(1)) SWIG_fail;
13989 {
13990 arg2 = (int)(SWIG_As_int(obj1));
13991 if (SWIG_arg_fail(2)) SWIG_fail;
13992 }
13993 if (obj2) {
13994 {
13995 arg3 = (bool)(SWIG_As_bool(obj2));
13996 if (SWIG_arg_fail(3)) SWIG_fail;
13997 }
13998 }
13999 {
14000 PyThreadState* __tstate = wxPyBeginAllowThreads();
14001 (arg1)->SetDefaultColSize(arg2,arg3);
14002
14003 wxPyEndAllowThreads(__tstate);
14004 if (PyErr_Occurred()) SWIG_fail;
14005 }
14006 Py_INCREF(Py_None); resultobj = Py_None;
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj;
14015 wxGrid *arg1 = (wxGrid *) 0 ;
14016 int arg2 ;
14017 int arg3 ;
14018 PyObject * obj0 = 0 ;
14019 PyObject * obj1 = 0 ;
14020 PyObject * obj2 = 0 ;
14021 char *kwnames[] = {
14022 (char *) "self",(char *) "col",(char *) "width", NULL
14023 };
14024
14025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14027 if (SWIG_arg_fail(1)) SWIG_fail;
14028 {
14029 arg2 = (int)(SWIG_As_int(obj1));
14030 if (SWIG_arg_fail(2)) SWIG_fail;
14031 }
14032 {
14033 arg3 = (int)(SWIG_As_int(obj2));
14034 if (SWIG_arg_fail(3)) SWIG_fail;
14035 }
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 (arg1)->SetColSize(arg2,arg3);
14039
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 Py_INCREF(Py_None); resultobj = Py_None;
14044 return resultobj;
14045 fail:
14046 return NULL;
14047 }
14048
14049
14050 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14051 PyObject *resultobj;
14052 wxGrid *arg1 = (wxGrid *) 0 ;
14053 int arg2 ;
14054 bool arg3 = (bool) true ;
14055 PyObject * obj0 = 0 ;
14056 PyObject * obj1 = 0 ;
14057 PyObject * obj2 = 0 ;
14058 char *kwnames[] = {
14059 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14060 };
14061
14062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14064 if (SWIG_arg_fail(1)) SWIG_fail;
14065 {
14066 arg2 = (int)(SWIG_As_int(obj1));
14067 if (SWIG_arg_fail(2)) SWIG_fail;
14068 }
14069 if (obj2) {
14070 {
14071 arg3 = (bool)(SWIG_As_bool(obj2));
14072 if (SWIG_arg_fail(3)) SWIG_fail;
14073 }
14074 }
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 (arg1)->AutoSizeColumn(arg2,arg3);
14078
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 Py_INCREF(Py_None); resultobj = Py_None;
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj;
14091 wxGrid *arg1 = (wxGrid *) 0 ;
14092 int arg2 ;
14093 bool arg3 = (bool) true ;
14094 PyObject * obj0 = 0 ;
14095 PyObject * obj1 = 0 ;
14096 PyObject * obj2 = 0 ;
14097 char *kwnames[] = {
14098 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14099 };
14100
14101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(1)) SWIG_fail;
14104 {
14105 arg2 = (int)(SWIG_As_int(obj1));
14106 if (SWIG_arg_fail(2)) SWIG_fail;
14107 }
14108 if (obj2) {
14109 {
14110 arg3 = (bool)(SWIG_As_bool(obj2));
14111 if (SWIG_arg_fail(3)) SWIG_fail;
14112 }
14113 }
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 (arg1)->AutoSizeRow(arg2,arg3);
14117
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 Py_INCREF(Py_None); resultobj = Py_None;
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14129 PyObject *resultobj;
14130 wxGrid *arg1 = (wxGrid *) 0 ;
14131 bool arg2 = (bool) true ;
14132 PyObject * obj0 = 0 ;
14133 PyObject * obj1 = 0 ;
14134 char *kwnames[] = {
14135 (char *) "self",(char *) "setAsMin", NULL
14136 };
14137
14138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14140 if (SWIG_arg_fail(1)) SWIG_fail;
14141 if (obj1) {
14142 {
14143 arg2 = (bool)(SWIG_As_bool(obj1));
14144 if (SWIG_arg_fail(2)) SWIG_fail;
14145 }
14146 }
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 (arg1)->AutoSizeColumns(arg2);
14150
14151 wxPyEndAllowThreads(__tstate);
14152 if (PyErr_Occurred()) SWIG_fail;
14153 }
14154 Py_INCREF(Py_None); resultobj = Py_None;
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxGrid *arg1 = (wxGrid *) 0 ;
14164 bool arg2 = (bool) true ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 char *kwnames[] = {
14168 (char *) "self",(char *) "setAsMin", NULL
14169 };
14170
14171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14173 if (SWIG_arg_fail(1)) SWIG_fail;
14174 if (obj1) {
14175 {
14176 arg2 = (bool)(SWIG_As_bool(obj1));
14177 if (SWIG_arg_fail(2)) SWIG_fail;
14178 }
14179 }
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 (arg1)->AutoSizeRows(arg2);
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 Py_INCREF(Py_None); resultobj = Py_None;
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj;
14196 wxGrid *arg1 = (wxGrid *) 0 ;
14197 PyObject * obj0 = 0 ;
14198 char *kwnames[] = {
14199 (char *) "self", NULL
14200 };
14201
14202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) goto fail;
14203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14204 if (SWIG_arg_fail(1)) SWIG_fail;
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 (arg1)->AutoSize();
14208
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 Py_INCREF(Py_None); resultobj = Py_None;
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14220 PyObject *resultobj;
14221 wxGrid *arg1 = (wxGrid *) 0 ;
14222 int arg2 ;
14223 PyObject * obj0 = 0 ;
14224 PyObject * obj1 = 0 ;
14225 char *kwnames[] = {
14226 (char *) "self",(char *) "row", NULL
14227 };
14228
14229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14231 if (SWIG_arg_fail(1)) SWIG_fail;
14232 {
14233 arg2 = (int)(SWIG_As_int(obj1));
14234 if (SWIG_arg_fail(2)) SWIG_fail;
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 (arg1)->AutoSizeRowLabelSize(arg2);
14239
14240 wxPyEndAllowThreads(__tstate);
14241 if (PyErr_Occurred()) SWIG_fail;
14242 }
14243 Py_INCREF(Py_None); resultobj = Py_None;
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj;
14252 wxGrid *arg1 = (wxGrid *) 0 ;
14253 int arg2 ;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 char *kwnames[] = {
14257 (char *) "self",(char *) "col", NULL
14258 };
14259
14260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14262 if (SWIG_arg_fail(1)) SWIG_fail;
14263 {
14264 arg2 = (int)(SWIG_As_int(obj1));
14265 if (SWIG_arg_fail(2)) SWIG_fail;
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 (arg1)->AutoSizeColLabelSize(arg2);
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 Py_INCREF(Py_None); resultobj = Py_None;
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj;
14283 wxGrid *arg1 = (wxGrid *) 0 ;
14284 int arg2 ;
14285 int arg3 ;
14286 PyObject * obj0 = 0 ;
14287 PyObject * obj1 = 0 ;
14288 PyObject * obj2 = 0 ;
14289 char *kwnames[] = {
14290 (char *) "self",(char *) "col",(char *) "width", NULL
14291 };
14292
14293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
14294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14295 if (SWIG_arg_fail(1)) SWIG_fail;
14296 {
14297 arg2 = (int)(SWIG_As_int(obj1));
14298 if (SWIG_arg_fail(2)) SWIG_fail;
14299 }
14300 {
14301 arg3 = (int)(SWIG_As_int(obj2));
14302 if (SWIG_arg_fail(3)) SWIG_fail;
14303 }
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 (arg1)->SetColMinimalWidth(arg2,arg3);
14307
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 Py_INCREF(Py_None); resultobj = Py_None;
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj;
14320 wxGrid *arg1 = (wxGrid *) 0 ;
14321 int arg2 ;
14322 int arg3 ;
14323 PyObject * obj0 = 0 ;
14324 PyObject * obj1 = 0 ;
14325 PyObject * obj2 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "self",(char *) "row",(char *) "width", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 arg2 = (int)(SWIG_As_int(obj1));
14335 if (SWIG_arg_fail(2)) SWIG_fail;
14336 }
14337 {
14338 arg3 = (int)(SWIG_As_int(obj2));
14339 if (SWIG_arg_fail(3)) SWIG_fail;
14340 }
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 (arg1)->SetRowMinimalHeight(arg2,arg3);
14344
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 Py_INCREF(Py_None); resultobj = Py_None;
14349 return resultobj;
14350 fail:
14351 return NULL;
14352 }
14353
14354
14355 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj;
14357 wxGrid *arg1 = (wxGrid *) 0 ;
14358 int arg2 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 char *kwnames[] = {
14362 (char *) "self",(char *) "width", NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14367 if (SWIG_arg_fail(1)) SWIG_fail;
14368 {
14369 arg2 = (int)(SWIG_As_int(obj1));
14370 if (SWIG_arg_fail(2)) SWIG_fail;
14371 }
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 (arg1)->SetColMinimalAcceptableWidth(arg2);
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 Py_INCREF(Py_None); resultobj = Py_None;
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj;
14388 wxGrid *arg1 = (wxGrid *) 0 ;
14389 int arg2 ;
14390 PyObject * obj0 = 0 ;
14391 PyObject * obj1 = 0 ;
14392 char *kwnames[] = {
14393 (char *) "self",(char *) "width", NULL
14394 };
14395
14396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14398 if (SWIG_arg_fail(1)) SWIG_fail;
14399 {
14400 arg2 = (int)(SWIG_As_int(obj1));
14401 if (SWIG_arg_fail(2)) SWIG_fail;
14402 }
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14406
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 Py_INCREF(Py_None); resultobj = Py_None;
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj;
14419 wxGrid *arg1 = (wxGrid *) 0 ;
14420 int result;
14421 PyObject * obj0 = 0 ;
14422 char *kwnames[] = {
14423 (char *) "self", NULL
14424 };
14425
14426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14428 if (SWIG_arg_fail(1)) SWIG_fail;
14429 {
14430 PyThreadState* __tstate = wxPyBeginAllowThreads();
14431 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14432
14433 wxPyEndAllowThreads(__tstate);
14434 if (PyErr_Occurred()) SWIG_fail;
14435 }
14436 {
14437 resultobj = SWIG_From_int((int)(result));
14438 }
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxGrid *arg1 = (wxGrid *) 0 ;
14448 int result;
14449 PyObject * obj0 = 0 ;
14450 char *kwnames[] = {
14451 (char *) "self", NULL
14452 };
14453
14454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14456 if (SWIG_arg_fail(1)) SWIG_fail;
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14460
14461 wxPyEndAllowThreads(__tstate);
14462 if (PyErr_Occurred()) SWIG_fail;
14463 }
14464 {
14465 resultobj = SWIG_From_int((int)(result));
14466 }
14467 return resultobj;
14468 fail:
14469 return NULL;
14470 }
14471
14472
14473 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14474 PyObject *resultobj;
14475 wxGrid *arg1 = (wxGrid *) 0 ;
14476 wxColour *arg2 = 0 ;
14477 wxColour temp2 ;
14478 PyObject * obj0 = 0 ;
14479 PyObject * obj1 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self","arg2", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 arg2 = &temp2;
14489 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxGrid *arg1 = (wxGrid *) 0 ;
14508 int arg2 ;
14509 int arg3 ;
14510 wxColour *arg4 = 0 ;
14511 wxColour temp4 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 PyObject * obj3 = 0 ;
14516 char *kwnames[] = {
14517 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14518 };
14519
14520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14522 if (SWIG_arg_fail(1)) SWIG_fail;
14523 {
14524 arg2 = (int)(SWIG_As_int(obj1));
14525 if (SWIG_arg_fail(2)) SWIG_fail;
14526 }
14527 {
14528 arg3 = (int)(SWIG_As_int(obj2));
14529 if (SWIG_arg_fail(3)) SWIG_fail;
14530 }
14531 {
14532 arg4 = &temp4;
14533 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14534 }
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14538
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 Py_INCREF(Py_None); resultobj = Py_None;
14543 return resultobj;
14544 fail:
14545 return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14550 PyObject *resultobj;
14551 wxGrid *arg1 = (wxGrid *) 0 ;
14552 wxColour *arg2 = 0 ;
14553 wxColour temp2 ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self","arg2", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 arg2 = &temp2;
14565 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14566 }
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 Py_INCREF(Py_None); resultobj = Py_None;
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxGrid *arg1 = (wxGrid *) 0 ;
14584 int arg2 ;
14585 int arg3 ;
14586 wxColour *arg4 = 0 ;
14587 wxColour temp4 ;
14588 PyObject * obj0 = 0 ;
14589 PyObject * obj1 = 0 ;
14590 PyObject * obj2 = 0 ;
14591 PyObject * obj3 = 0 ;
14592 char *kwnames[] = {
14593 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14594 };
14595
14596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14598 if (SWIG_arg_fail(1)) SWIG_fail;
14599 {
14600 arg2 = (int)(SWIG_As_int(obj1));
14601 if (SWIG_arg_fail(2)) SWIG_fail;
14602 }
14603 {
14604 arg3 = (int)(SWIG_As_int(obj2));
14605 if (SWIG_arg_fail(3)) SWIG_fail;
14606 }
14607 {
14608 arg4 = &temp4;
14609 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14610 }
14611 {
14612 PyThreadState* __tstate = wxPyBeginAllowThreads();
14613 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14614
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 Py_INCREF(Py_None); resultobj = Py_None;
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14626 PyObject *resultobj;
14627 wxGrid *arg1 = (wxGrid *) 0 ;
14628 wxFont *arg2 = 0 ;
14629 PyObject * obj0 = 0 ;
14630 PyObject * obj1 = 0 ;
14631 char *kwnames[] = {
14632 (char *) "self","arg2", NULL
14633 };
14634
14635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14637 if (SWIG_arg_fail(1)) SWIG_fail;
14638 {
14639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14640 if (SWIG_arg_fail(2)) SWIG_fail;
14641 if (arg2 == NULL) {
14642 SWIG_null_ref("wxFont");
14643 }
14644 if (SWIG_arg_fail(2)) SWIG_fail;
14645 }
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14649
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 Py_INCREF(Py_None); resultobj = Py_None;
14654 return resultobj;
14655 fail:
14656 return NULL;
14657 }
14658
14659
14660 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14661 PyObject *resultobj;
14662 wxGrid *arg1 = (wxGrid *) 0 ;
14663 int arg2 ;
14664 int arg3 ;
14665 wxFont *arg4 = 0 ;
14666 PyObject * obj0 = 0 ;
14667 PyObject * obj1 = 0 ;
14668 PyObject * obj2 = 0 ;
14669 PyObject * obj3 = 0 ;
14670 char *kwnames[] = {
14671 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14672 };
14673
14674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14676 if (SWIG_arg_fail(1)) SWIG_fail;
14677 {
14678 arg2 = (int)(SWIG_As_int(obj1));
14679 if (SWIG_arg_fail(2)) SWIG_fail;
14680 }
14681 {
14682 arg3 = (int)(SWIG_As_int(obj2));
14683 if (SWIG_arg_fail(3)) SWIG_fail;
14684 }
14685 {
14686 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14687 if (SWIG_arg_fail(4)) SWIG_fail;
14688 if (arg4 == NULL) {
14689 SWIG_null_ref("wxFont");
14690 }
14691 if (SWIG_arg_fail(4)) SWIG_fail;
14692 }
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->SetCellFont(arg2,arg3,(wxFont 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_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj;
14709 wxGrid *arg1 = (wxGrid *) 0 ;
14710 int arg2 ;
14711 int arg3 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 PyObject * obj2 = 0 ;
14715 char *kwnames[] = {
14716 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14717 };
14718
14719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14721 if (SWIG_arg_fail(1)) SWIG_fail;
14722 {
14723 arg2 = (int)(SWIG_As_int(obj1));
14724 if (SWIG_arg_fail(2)) SWIG_fail;
14725 }
14726 {
14727 arg3 = (int)(SWIG_As_int(obj2));
14728 if (SWIG_arg_fail(3)) SWIG_fail;
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14733
14734 wxPyEndAllowThreads(__tstate);
14735 if (PyErr_Occurred()) SWIG_fail;
14736 }
14737 Py_INCREF(Py_None); resultobj = Py_None;
14738 return resultobj;
14739 fail:
14740 return NULL;
14741 }
14742
14743
14744 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14745 PyObject *resultobj;
14746 wxGrid *arg1 = (wxGrid *) 0 ;
14747 int arg2 ;
14748 int arg3 ;
14749 int arg4 ;
14750 int arg5 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 PyObject * obj2 = 0 ;
14754 PyObject * obj3 = 0 ;
14755 PyObject * obj4 = 0 ;
14756 char *kwnames[] = {
14757 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14758 };
14759
14760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14762 if (SWIG_arg_fail(1)) SWIG_fail;
14763 {
14764 arg2 = (int)(SWIG_As_int(obj1));
14765 if (SWIG_arg_fail(2)) SWIG_fail;
14766 }
14767 {
14768 arg3 = (int)(SWIG_As_int(obj2));
14769 if (SWIG_arg_fail(3)) SWIG_fail;
14770 }
14771 {
14772 arg4 = (int)(SWIG_As_int(obj3));
14773 if (SWIG_arg_fail(4)) SWIG_fail;
14774 }
14775 {
14776 arg5 = (int)(SWIG_As_int(obj4));
14777 if (SWIG_arg_fail(5)) SWIG_fail;
14778 }
14779 {
14780 PyThreadState* __tstate = wxPyBeginAllowThreads();
14781 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
14782
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 Py_INCREF(Py_None); resultobj = Py_None;
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14794 PyObject *resultobj;
14795 wxGrid *arg1 = (wxGrid *) 0 ;
14796 bool arg2 ;
14797 PyObject * obj0 = 0 ;
14798 PyObject * obj1 = 0 ;
14799 char *kwnames[] = {
14800 (char *) "self",(char *) "allow", NULL
14801 };
14802
14803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
14804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14805 if (SWIG_arg_fail(1)) SWIG_fail;
14806 {
14807 arg2 = (bool)(SWIG_As_bool(obj1));
14808 if (SWIG_arg_fail(2)) SWIG_fail;
14809 }
14810 {
14811 PyThreadState* __tstate = wxPyBeginAllowThreads();
14812 (arg1)->SetDefaultCellOverflow(arg2);
14813
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 Py_INCREF(Py_None); resultobj = Py_None;
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14825 PyObject *resultobj;
14826 wxGrid *arg1 = (wxGrid *) 0 ;
14827 int arg2 ;
14828 int arg3 ;
14829 bool arg4 ;
14830 PyObject * obj0 = 0 ;
14831 PyObject * obj1 = 0 ;
14832 PyObject * obj2 = 0 ;
14833 PyObject * obj3 = 0 ;
14834 char *kwnames[] = {
14835 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
14836 };
14837
14838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 {
14842 arg2 = (int)(SWIG_As_int(obj1));
14843 if (SWIG_arg_fail(2)) SWIG_fail;
14844 }
14845 {
14846 arg3 = (int)(SWIG_As_int(obj2));
14847 if (SWIG_arg_fail(3)) SWIG_fail;
14848 }
14849 {
14850 arg4 = (bool)(SWIG_As_bool(obj3));
14851 if (SWIG_arg_fail(4)) SWIG_fail;
14852 }
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 (arg1)->SetCellOverflow(arg2,arg3,arg4);
14856
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 Py_INCREF(Py_None); resultobj = Py_None;
14861 return resultobj;
14862 fail:
14863 return NULL;
14864 }
14865
14866
14867 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj;
14869 wxGrid *arg1 = (wxGrid *) 0 ;
14870 int arg2 ;
14871 int arg3 ;
14872 int arg4 ;
14873 int arg5 ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 PyObject * obj3 = 0 ;
14878 PyObject * obj4 = 0 ;
14879 char *kwnames[] = {
14880 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
14881 };
14882
14883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14885 if (SWIG_arg_fail(1)) SWIG_fail;
14886 {
14887 arg2 = (int)(SWIG_As_int(obj1));
14888 if (SWIG_arg_fail(2)) SWIG_fail;
14889 }
14890 {
14891 arg3 = (int)(SWIG_As_int(obj2));
14892 if (SWIG_arg_fail(3)) SWIG_fail;
14893 }
14894 {
14895 arg4 = (int)(SWIG_As_int(obj3));
14896 if (SWIG_arg_fail(4)) SWIG_fail;
14897 }
14898 {
14899 arg5 = (int)(SWIG_As_int(obj4));
14900 if (SWIG_arg_fail(5)) SWIG_fail;
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
14905
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 Py_INCREF(Py_None); resultobj = Py_None;
14910 return resultobj;
14911 fail:
14912 return NULL;
14913 }
14914
14915
14916 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14917 PyObject *resultobj;
14918 wxGrid *arg1 = (wxGrid *) 0 ;
14919 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
14920 PyObject * obj0 = 0 ;
14921 PyObject * obj1 = 0 ;
14922 char *kwnames[] = {
14923 (char *) "self",(char *) "renderer", NULL
14924 };
14925
14926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
14927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14928 if (SWIG_arg_fail(1)) SWIG_fail;
14929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14930 if (SWIG_arg_fail(2)) SWIG_fail;
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 (arg1)->SetDefaultRenderer(arg2);
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 Py_INCREF(Py_None); resultobj = Py_None;
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj;
14947 wxGrid *arg1 = (wxGrid *) 0 ;
14948 int arg2 ;
14949 int arg3 ;
14950 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
14951 PyObject * obj0 = 0 ;
14952 PyObject * obj1 = 0 ;
14953 PyObject * obj2 = 0 ;
14954 PyObject * obj3 = 0 ;
14955 char *kwnames[] = {
14956 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
14957 };
14958
14959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14961 if (SWIG_arg_fail(1)) SWIG_fail;
14962 {
14963 arg2 = (int)(SWIG_As_int(obj1));
14964 if (SWIG_arg_fail(2)) SWIG_fail;
14965 }
14966 {
14967 arg3 = (int)(SWIG_As_int(obj2));
14968 if (SWIG_arg_fail(3)) SWIG_fail;
14969 }
14970 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14971 if (SWIG_arg_fail(4)) SWIG_fail;
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 (arg1)->SetCellRenderer(arg2,arg3,arg4);
14975
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 Py_INCREF(Py_None); resultobj = Py_None;
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj;
14988 wxGrid *arg1 = (wxGrid *) 0 ;
14989 wxGridCellRenderer *result;
14990 PyObject * obj0 = 0 ;
14991 char *kwnames[] = {
14992 (char *) "self", NULL
14993 };
14994
14995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
14996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14997 if (SWIG_arg_fail(1)) SWIG_fail;
14998 {
14999 PyThreadState* __tstate = wxPyBeginAllowThreads();
15000 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15001
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 {
15006 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15007 }
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj;
15016 wxGrid *arg1 = (wxGrid *) 0 ;
15017 int arg2 ;
15018 int arg3 ;
15019 wxGridCellRenderer *result;
15020 PyObject * obj0 = 0 ;
15021 PyObject * obj1 = 0 ;
15022 PyObject * obj2 = 0 ;
15023 char *kwnames[] = {
15024 (char *) "self",(char *) "row",(char *) "col", NULL
15025 };
15026
15027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15029 if (SWIG_arg_fail(1)) SWIG_fail;
15030 {
15031 arg2 = (int)(SWIG_As_int(obj1));
15032 if (SWIG_arg_fail(2)) SWIG_fail;
15033 }
15034 {
15035 arg3 = (int)(SWIG_As_int(obj2));
15036 if (SWIG_arg_fail(3)) SWIG_fail;
15037 }
15038 {
15039 PyThreadState* __tstate = wxPyBeginAllowThreads();
15040 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15041
15042 wxPyEndAllowThreads(__tstate);
15043 if (PyErr_Occurred()) SWIG_fail;
15044 }
15045 {
15046 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15047 }
15048 return resultobj;
15049 fail:
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxGrid *arg1 = (wxGrid *) 0 ;
15057 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15058 PyObject * obj0 = 0 ;
15059 PyObject * obj1 = 0 ;
15060 char *kwnames[] = {
15061 (char *) "self",(char *) "editor", NULL
15062 };
15063
15064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15066 if (SWIG_arg_fail(1)) SWIG_fail;
15067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15068 if (SWIG_arg_fail(2)) SWIG_fail;
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 (arg1)->SetDefaultEditor(arg2);
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 Py_INCREF(Py_None); resultobj = Py_None;
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj;
15085 wxGrid *arg1 = (wxGrid *) 0 ;
15086 int arg2 ;
15087 int arg3 ;
15088 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15089 PyObject * obj0 = 0 ;
15090 PyObject * obj1 = 0 ;
15091 PyObject * obj2 = 0 ;
15092 PyObject * obj3 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15099 if (SWIG_arg_fail(1)) SWIG_fail;
15100 {
15101 arg2 = (int)(SWIG_As_int(obj1));
15102 if (SWIG_arg_fail(2)) SWIG_fail;
15103 }
15104 {
15105 arg3 = (int)(SWIG_As_int(obj2));
15106 if (SWIG_arg_fail(3)) SWIG_fail;
15107 }
15108 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(4)) SWIG_fail;
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 (arg1)->SetCellEditor(arg2,arg3,arg4);
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 Py_INCREF(Py_None); resultobj = Py_None;
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxGrid *arg1 = (wxGrid *) 0 ;
15127 wxGridCellEditor *result;
15128 PyObject * obj0 = 0 ;
15129 char *kwnames[] = {
15130 (char *) "self", NULL
15131 };
15132
15133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15135 if (SWIG_arg_fail(1)) SWIG_fail;
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 {
15144 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15145 }
15146 return resultobj;
15147 fail:
15148 return NULL;
15149 }
15150
15151
15152 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj;
15154 wxGrid *arg1 = (wxGrid *) 0 ;
15155 int arg2 ;
15156 int arg3 ;
15157 wxGridCellEditor *result;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 PyObject * obj2 = 0 ;
15161 char *kwnames[] = {
15162 (char *) "self",(char *) "row",(char *) "col", NULL
15163 };
15164
15165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15167 if (SWIG_arg_fail(1)) SWIG_fail;
15168 {
15169 arg2 = (int)(SWIG_As_int(obj1));
15170 if (SWIG_arg_fail(2)) SWIG_fail;
15171 }
15172 {
15173 arg3 = (int)(SWIG_As_int(obj2));
15174 if (SWIG_arg_fail(3)) SWIG_fail;
15175 }
15176 {
15177 PyThreadState* __tstate = wxPyBeginAllowThreads();
15178 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15179
15180 wxPyEndAllowThreads(__tstate);
15181 if (PyErr_Occurred()) SWIG_fail;
15182 }
15183 {
15184 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15185 }
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxGrid *arg1 = (wxGrid *) 0 ;
15195 int arg2 ;
15196 int arg3 ;
15197 wxString result;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 PyObject * obj2 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "row",(char *) "col", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = (int)(SWIG_As_int(obj1));
15210 if (SWIG_arg_fail(2)) SWIG_fail;
15211 }
15212 {
15213 arg3 = (int)(SWIG_As_int(obj2));
15214 if (SWIG_arg_fail(3)) SWIG_fail;
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (arg1)->GetCellValue(arg2,arg3);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 {
15224 #if wxUSE_UNICODE
15225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15226 #else
15227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15228 #endif
15229 }
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxGrid *arg1 = (wxGrid *) 0 ;
15239 int arg2 ;
15240 int arg3 ;
15241 wxString *arg4 = 0 ;
15242 bool temp4 = false ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 PyObject * obj2 = 0 ;
15246 PyObject * obj3 = 0 ;
15247 char *kwnames[] = {
15248 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15249 };
15250
15251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15253 if (SWIG_arg_fail(1)) SWIG_fail;
15254 {
15255 arg2 = (int)(SWIG_As_int(obj1));
15256 if (SWIG_arg_fail(2)) SWIG_fail;
15257 }
15258 {
15259 arg3 = (int)(SWIG_As_int(obj2));
15260 if (SWIG_arg_fail(3)) SWIG_fail;
15261 }
15262 {
15263 arg4 = wxString_in_helper(obj3);
15264 if (arg4 == NULL) SWIG_fail;
15265 temp4 = true;
15266 }
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15270
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 Py_INCREF(Py_None); resultobj = Py_None;
15275 {
15276 if (temp4)
15277 delete arg4;
15278 }
15279 return resultobj;
15280 fail:
15281 {
15282 if (temp4)
15283 delete arg4;
15284 }
15285 return NULL;
15286 }
15287
15288
15289 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15290 PyObject *resultobj;
15291 wxGrid *arg1 = (wxGrid *) 0 ;
15292 int arg2 ;
15293 int arg3 ;
15294 bool result;
15295 PyObject * obj0 = 0 ;
15296 PyObject * obj1 = 0 ;
15297 PyObject * obj2 = 0 ;
15298 char *kwnames[] = {
15299 (char *) "self",(char *) "row",(char *) "col", NULL
15300 };
15301
15302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15304 if (SWIG_arg_fail(1)) SWIG_fail;
15305 {
15306 arg2 = (int)(SWIG_As_int(obj1));
15307 if (SWIG_arg_fail(2)) SWIG_fail;
15308 }
15309 {
15310 arg3 = (int)(SWIG_As_int(obj2));
15311 if (SWIG_arg_fail(3)) SWIG_fail;
15312 }
15313 {
15314 PyThreadState* __tstate = wxPyBeginAllowThreads();
15315 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15316
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 {
15321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15322 }
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15330 PyObject *resultobj;
15331 wxGrid *arg1 = (wxGrid *) 0 ;
15332 int arg2 ;
15333 int arg3 ;
15334 bool arg4 = (bool) true ;
15335 PyObject * obj0 = 0 ;
15336 PyObject * obj1 = 0 ;
15337 PyObject * obj2 = 0 ;
15338 PyObject * obj3 = 0 ;
15339 char *kwnames[] = {
15340 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15341 };
15342
15343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(1)) SWIG_fail;
15346 {
15347 arg2 = (int)(SWIG_As_int(obj1));
15348 if (SWIG_arg_fail(2)) SWIG_fail;
15349 }
15350 {
15351 arg3 = (int)(SWIG_As_int(obj2));
15352 if (SWIG_arg_fail(3)) SWIG_fail;
15353 }
15354 if (obj3) {
15355 {
15356 arg4 = (bool)(SWIG_As_bool(obj3));
15357 if (SWIG_arg_fail(4)) SWIG_fail;
15358 }
15359 }
15360 {
15361 PyThreadState* __tstate = wxPyBeginAllowThreads();
15362 (arg1)->SetReadOnly(arg2,arg3,arg4);
15363
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 Py_INCREF(Py_None); resultobj = Py_None;
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj;
15376 wxGrid *arg1 = (wxGrid *) 0 ;
15377 int arg2 ;
15378 bool arg3 = (bool) false ;
15379 PyObject * obj0 = 0 ;
15380 PyObject * obj1 = 0 ;
15381 PyObject * obj2 = 0 ;
15382 char *kwnames[] = {
15383 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15384 };
15385
15386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15388 if (SWIG_arg_fail(1)) SWIG_fail;
15389 {
15390 arg2 = (int)(SWIG_As_int(obj1));
15391 if (SWIG_arg_fail(2)) SWIG_fail;
15392 }
15393 if (obj2) {
15394 {
15395 arg3 = (bool)(SWIG_As_bool(obj2));
15396 if (SWIG_arg_fail(3)) SWIG_fail;
15397 }
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->SelectRow(arg2,arg3);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxGrid *arg1 = (wxGrid *) 0 ;
15416 int arg2 ;
15417 bool arg3 = (bool) false ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 PyObject * obj2 = 0 ;
15421 char *kwnames[] = {
15422 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15423 };
15424
15425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(1)) SWIG_fail;
15428 {
15429 arg2 = (int)(SWIG_As_int(obj1));
15430 if (SWIG_arg_fail(2)) SWIG_fail;
15431 }
15432 if (obj2) {
15433 {
15434 arg3 = (bool)(SWIG_As_bool(obj2));
15435 if (SWIG_arg_fail(3)) SWIG_fail;
15436 }
15437 }
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 (arg1)->SelectCol(arg2,arg3);
15441
15442 wxPyEndAllowThreads(__tstate);
15443 if (PyErr_Occurred()) SWIG_fail;
15444 }
15445 Py_INCREF(Py_None); resultobj = Py_None;
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15453 PyObject *resultobj;
15454 wxGrid *arg1 = (wxGrid *) 0 ;
15455 int arg2 ;
15456 int arg3 ;
15457 int arg4 ;
15458 int arg5 ;
15459 bool arg6 = (bool) false ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 PyObject * obj2 = 0 ;
15463 PyObject * obj3 = 0 ;
15464 PyObject * obj4 = 0 ;
15465 PyObject * obj5 = 0 ;
15466 char *kwnames[] = {
15467 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15468 };
15469
15470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15472 if (SWIG_arg_fail(1)) SWIG_fail;
15473 {
15474 arg2 = (int)(SWIG_As_int(obj1));
15475 if (SWIG_arg_fail(2)) SWIG_fail;
15476 }
15477 {
15478 arg3 = (int)(SWIG_As_int(obj2));
15479 if (SWIG_arg_fail(3)) SWIG_fail;
15480 }
15481 {
15482 arg4 = (int)(SWIG_As_int(obj3));
15483 if (SWIG_arg_fail(4)) SWIG_fail;
15484 }
15485 {
15486 arg5 = (int)(SWIG_As_int(obj4));
15487 if (SWIG_arg_fail(5)) SWIG_fail;
15488 }
15489 if (obj5) {
15490 {
15491 arg6 = (bool)(SWIG_As_bool(obj5));
15492 if (SWIG_arg_fail(6)) SWIG_fail;
15493 }
15494 }
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15498
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 Py_INCREF(Py_None); resultobj = Py_None;
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj;
15511 wxGrid *arg1 = (wxGrid *) 0 ;
15512 PyObject * obj0 = 0 ;
15513 char *kwnames[] = {
15514 (char *) "self", NULL
15515 };
15516
15517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15519 if (SWIG_arg_fail(1)) SWIG_fail;
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 (arg1)->SelectAll();
15523
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 Py_INCREF(Py_None); resultobj = Py_None;
15528 return resultobj;
15529 fail:
15530 return NULL;
15531 }
15532
15533
15534 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj;
15536 wxGrid *arg1 = (wxGrid *) 0 ;
15537 bool result;
15538 PyObject * obj0 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 result = (bool)(arg1)->IsSelection();
15549
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 {
15554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15555 }
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15563 PyObject *resultobj;
15564 wxGrid *arg1 = (wxGrid *) 0 ;
15565 PyObject * obj0 = 0 ;
15566 char *kwnames[] = {
15567 (char *) "self", NULL
15568 };
15569
15570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15572 if (SWIG_arg_fail(1)) SWIG_fail;
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 (arg1)->ClearSelection();
15576
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 Py_INCREF(Py_None); resultobj = Py_None;
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15588 PyObject *resultobj;
15589 wxGrid *arg1 = (wxGrid *) 0 ;
15590 int arg2 ;
15591 int arg3 ;
15592 bool result;
15593 PyObject * obj0 = 0 ;
15594 PyObject * obj1 = 0 ;
15595 PyObject * obj2 = 0 ;
15596 char *kwnames[] = {
15597 (char *) "self",(char *) "row",(char *) "col", NULL
15598 };
15599
15600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15602 if (SWIG_arg_fail(1)) SWIG_fail;
15603 {
15604 arg2 = (int)(SWIG_As_int(obj1));
15605 if (SWIG_arg_fail(2)) SWIG_fail;
15606 }
15607 {
15608 arg3 = (int)(SWIG_As_int(obj2));
15609 if (SWIG_arg_fail(3)) SWIG_fail;
15610 }
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15614
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 {
15619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15620 }
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15628 PyObject *resultobj;
15629 wxGrid *arg1 = (wxGrid *) 0 ;
15630 wxGridCellCoordsArray result;
15631 PyObject * obj0 = 0 ;
15632 char *kwnames[] = {
15633 (char *) "self", NULL
15634 };
15635
15636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15638 if (SWIG_arg_fail(1)) SWIG_fail;
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 result = ((wxGrid const *)arg1)->GetSelectedCells();
15642
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 {
15647 resultobj = wxGridCellCoordsArray_helper(result);
15648 }
15649 return resultobj;
15650 fail:
15651 return NULL;
15652 }
15653
15654
15655 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15656 PyObject *resultobj;
15657 wxGrid *arg1 = (wxGrid *) 0 ;
15658 wxGridCellCoordsArray result;
15659 PyObject * obj0 = 0 ;
15660 char *kwnames[] = {
15661 (char *) "self", NULL
15662 };
15663
15664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) goto fail;
15665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15666 if (SWIG_arg_fail(1)) SWIG_fail;
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15670
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 {
15675 resultobj = wxGridCellCoordsArray_helper(result);
15676 }
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15684 PyObject *resultobj;
15685 wxGrid *arg1 = (wxGrid *) 0 ;
15686 wxGridCellCoordsArray result;
15687 PyObject * obj0 = 0 ;
15688 char *kwnames[] = {
15689 (char *) "self", NULL
15690 };
15691
15692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15694 if (SWIG_arg_fail(1)) SWIG_fail;
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15698
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 {
15703 resultobj = wxGridCellCoordsArray_helper(result);
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj;
15713 wxGrid *arg1 = (wxGrid *) 0 ;
15714 wxArrayInt result;
15715 PyObject * obj0 = 0 ;
15716 char *kwnames[] = {
15717 (char *) "self", NULL
15718 };
15719
15720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15722 if (SWIG_arg_fail(1)) SWIG_fail;
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = ((wxGrid const *)arg1)->GetSelectedRows();
15726
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 {
15731 resultobj = PyList_New(0);
15732 size_t idx;
15733 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15734 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15735 PyList_Append(resultobj, val);
15736 Py_DECREF(val);
15737 }
15738 }
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj;
15747 wxGrid *arg1 = (wxGrid *) 0 ;
15748 wxArrayInt result;
15749 PyObject * obj0 = 0 ;
15750 char *kwnames[] = {
15751 (char *) "self", NULL
15752 };
15753
15754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15756 if (SWIG_arg_fail(1)) SWIG_fail;
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = ((wxGrid const *)arg1)->GetSelectedCols();
15760
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = PyList_New(0);
15766 size_t idx;
15767 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15768 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15769 PyList_Append(resultobj, val);
15770 Py_DECREF(val);
15771 }
15772 }
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15780 PyObject *resultobj;
15781 wxGrid *arg1 = (wxGrid *) 0 ;
15782 int arg2 ;
15783 PyObject * obj0 = 0 ;
15784 PyObject * obj1 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "self",(char *) "row", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
15790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15791 if (SWIG_arg_fail(1)) SWIG_fail;
15792 {
15793 arg2 = (int)(SWIG_As_int(obj1));
15794 if (SWIG_arg_fail(2)) SWIG_fail;
15795 }
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 (arg1)->DeselectRow(arg2);
15799
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 Py_INCREF(Py_None); resultobj = Py_None;
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj;
15812 wxGrid *arg1 = (wxGrid *) 0 ;
15813 int arg2 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char *kwnames[] = {
15817 (char *) "self",(char *) "col", NULL
15818 };
15819
15820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
15821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15822 if (SWIG_arg_fail(1)) SWIG_fail;
15823 {
15824 arg2 = (int)(SWIG_As_int(obj1));
15825 if (SWIG_arg_fail(2)) SWIG_fail;
15826 }
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 (arg1)->DeselectCol(arg2);
15830
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 Py_INCREF(Py_None); resultobj = Py_None;
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxGrid *arg1 = (wxGrid *) 0 ;
15844 int arg2 ;
15845 int arg3 ;
15846 PyObject * obj0 = 0 ;
15847 PyObject * obj1 = 0 ;
15848 PyObject * obj2 = 0 ;
15849 char *kwnames[] = {
15850 (char *) "self",(char *) "row",(char *) "col", NULL
15851 };
15852
15853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
15854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15855 if (SWIG_arg_fail(1)) SWIG_fail;
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 {
15861 arg3 = (int)(SWIG_As_int(obj2));
15862 if (SWIG_arg_fail(3)) SWIG_fail;
15863 }
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 (arg1)->DeselectCell(arg2,arg3);
15867
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 Py_INCREF(Py_None); resultobj = Py_None;
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj;
15880 wxGrid *arg1 = (wxGrid *) 0 ;
15881 wxGridCellCoords *arg2 = 0 ;
15882 wxGridCellCoords *arg3 = 0 ;
15883 wxRect result;
15884 wxGridCellCoords temp2 ;
15885 wxGridCellCoords temp3 ;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 PyObject * obj2 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 arg2 = &temp2;
15898 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
15899 }
15900 {
15901 arg3 = &temp3;
15902 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
15903 }
15904 {
15905 PyThreadState* __tstate = wxPyBeginAllowThreads();
15906 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
15907
15908 wxPyEndAllowThreads(__tstate);
15909 if (PyErr_Occurred()) SWIG_fail;
15910 }
15911 {
15912 wxRect * resultptr;
15913 resultptr = new wxRect((wxRect &)(result));
15914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15915 }
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15923 PyObject *resultobj;
15924 wxGrid *arg1 = (wxGrid *) 0 ;
15925 wxColour result;
15926 PyObject * obj0 = 0 ;
15927 char *kwnames[] = {
15928 (char *) "self", NULL
15929 };
15930
15931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
15932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15933 if (SWIG_arg_fail(1)) SWIG_fail;
15934 {
15935 PyThreadState* __tstate = wxPyBeginAllowThreads();
15936 result = ((wxGrid const *)arg1)->GetSelectionBackground();
15937
15938 wxPyEndAllowThreads(__tstate);
15939 if (PyErr_Occurred()) SWIG_fail;
15940 }
15941 {
15942 wxColour * resultptr;
15943 resultptr = new wxColour((wxColour &)(result));
15944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15945 }
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj;
15954 wxGrid *arg1 = (wxGrid *) 0 ;
15955 wxColour result;
15956 PyObject * obj0 = 0 ;
15957 char *kwnames[] = {
15958 (char *) "self", NULL
15959 };
15960
15961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
15962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15963 if (SWIG_arg_fail(1)) SWIG_fail;
15964 {
15965 PyThreadState* __tstate = wxPyBeginAllowThreads();
15966 result = ((wxGrid const *)arg1)->GetSelectionForeground();
15967
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 {
15972 wxColour * resultptr;
15973 resultptr = new wxColour((wxColour &)(result));
15974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15975 }
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj;
15984 wxGrid *arg1 = (wxGrid *) 0 ;
15985 wxColour *arg2 = 0 ;
15986 wxColour temp2 ;
15987 PyObject * obj0 = 0 ;
15988 PyObject * obj1 = 0 ;
15989 char *kwnames[] = {
15990 (char *) "self",(char *) "c", NULL
15991 };
15992
15993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
15994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15995 if (SWIG_arg_fail(1)) SWIG_fail;
15996 {
15997 arg2 = &temp2;
15998 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15999 }
16000 {
16001 PyThreadState* __tstate = wxPyBeginAllowThreads();
16002 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16003
16004 wxPyEndAllowThreads(__tstate);
16005 if (PyErr_Occurred()) SWIG_fail;
16006 }
16007 Py_INCREF(Py_None); resultobj = Py_None;
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16015 PyObject *resultobj;
16016 wxGrid *arg1 = (wxGrid *) 0 ;
16017 wxColour *arg2 = 0 ;
16018 wxColour temp2 ;
16019 PyObject * obj0 = 0 ;
16020 PyObject * obj1 = 0 ;
16021 char *kwnames[] = {
16022 (char *) "self",(char *) "c", NULL
16023 };
16024
16025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) goto fail;
16026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16027 if (SWIG_arg_fail(1)) SWIG_fail;
16028 {
16029 arg2 = &temp2;
16030 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16031 }
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16035
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 Py_INCREF(Py_None); resultobj = Py_None;
16040 return resultobj;
16041 fail:
16042 return NULL;
16043 }
16044
16045
16046 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16047 PyObject *resultobj;
16048 wxGrid *arg1 = (wxGrid *) 0 ;
16049 wxString *arg2 = 0 ;
16050 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16051 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16052 bool temp2 = false ;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16063 if (SWIG_arg_fail(1)) SWIG_fail;
16064 {
16065 arg2 = wxString_in_helper(obj1);
16066 if (arg2 == NULL) SWIG_fail;
16067 temp2 = true;
16068 }
16069 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16070 if (SWIG_arg_fail(3)) SWIG_fail;
16071 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(4)) SWIG_fail;
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 Py_INCREF(Py_None); resultobj = Py_None;
16081 {
16082 if (temp2)
16083 delete arg2;
16084 }
16085 return resultobj;
16086 fail:
16087 {
16088 if (temp2)
16089 delete arg2;
16090 }
16091 return NULL;
16092 }
16093
16094
16095 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj;
16097 wxGrid *arg1 = (wxGrid *) 0 ;
16098 int arg2 ;
16099 int arg3 ;
16100 wxGridCellEditor *result;
16101 PyObject * obj0 = 0 ;
16102 PyObject * obj1 = 0 ;
16103 PyObject * obj2 = 0 ;
16104 char *kwnames[] = {
16105 (char *) "self",(char *) "row",(char *) "col", NULL
16106 };
16107
16108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16110 if (SWIG_arg_fail(1)) SWIG_fail;
16111 {
16112 arg2 = (int)(SWIG_As_int(obj1));
16113 if (SWIG_arg_fail(2)) SWIG_fail;
16114 }
16115 {
16116 arg3 = (int)(SWIG_As_int(obj2));
16117 if (SWIG_arg_fail(3)) SWIG_fail;
16118 }
16119 {
16120 PyThreadState* __tstate = wxPyBeginAllowThreads();
16121 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16122
16123 wxPyEndAllowThreads(__tstate);
16124 if (PyErr_Occurred()) SWIG_fail;
16125 }
16126 {
16127 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16128 }
16129 return resultobj;
16130 fail:
16131 return NULL;
16132 }
16133
16134
16135 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16136 PyObject *resultobj;
16137 wxGrid *arg1 = (wxGrid *) 0 ;
16138 int arg2 ;
16139 int arg3 ;
16140 wxGridCellRenderer *result;
16141 PyObject * obj0 = 0 ;
16142 PyObject * obj1 = 0 ;
16143 PyObject * obj2 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "self",(char *) "row",(char *) "col", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 arg2 = (int)(SWIG_As_int(obj1));
16153 if (SWIG_arg_fail(2)) SWIG_fail;
16154 }
16155 {
16156 arg3 = (int)(SWIG_As_int(obj2));
16157 if (SWIG_arg_fail(3)) SWIG_fail;
16158 }
16159 {
16160 PyThreadState* __tstate = wxPyBeginAllowThreads();
16161 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16162
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 {
16167 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16168 }
16169 return resultobj;
16170 fail:
16171 return NULL;
16172 }
16173
16174
16175 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16176 PyObject *resultobj;
16177 wxGrid *arg1 = (wxGrid *) 0 ;
16178 wxString *arg2 = 0 ;
16179 wxGridCellEditor *result;
16180 bool temp2 = false ;
16181 PyObject * obj0 = 0 ;
16182 PyObject * obj1 = 0 ;
16183 char *kwnames[] = {
16184 (char *) "self",(char *) "typeName", NULL
16185 };
16186
16187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16189 if (SWIG_arg_fail(1)) SWIG_fail;
16190 {
16191 arg2 = wxString_in_helper(obj1);
16192 if (arg2 == NULL) SWIG_fail;
16193 temp2 = true;
16194 }
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16198
16199 wxPyEndAllowThreads(__tstate);
16200 if (PyErr_Occurred()) SWIG_fail;
16201 }
16202 {
16203 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16204 }
16205 {
16206 if (temp2)
16207 delete arg2;
16208 }
16209 return resultobj;
16210 fail:
16211 {
16212 if (temp2)
16213 delete arg2;
16214 }
16215 return NULL;
16216 }
16217
16218
16219 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj;
16221 wxGrid *arg1 = (wxGrid *) 0 ;
16222 wxString *arg2 = 0 ;
16223 wxGridCellRenderer *result;
16224 bool temp2 = false ;
16225 PyObject * obj0 = 0 ;
16226 PyObject * obj1 = 0 ;
16227 char *kwnames[] = {
16228 (char *) "self",(char *) "typeName", NULL
16229 };
16230
16231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16233 if (SWIG_arg_fail(1)) SWIG_fail;
16234 {
16235 arg2 = wxString_in_helper(obj1);
16236 if (arg2 == NULL) SWIG_fail;
16237 temp2 = true;
16238 }
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16248 }
16249 {
16250 if (temp2)
16251 delete arg2;
16252 }
16253 return resultobj;
16254 fail:
16255 {
16256 if (temp2)
16257 delete arg2;
16258 }
16259 return NULL;
16260 }
16261
16262
16263 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj;
16265 wxGrid *arg1 = (wxGrid *) 0 ;
16266 int arg2 ;
16267 int arg3 ;
16268 PyObject * obj0 = 0 ;
16269 PyObject * obj1 = 0 ;
16270 PyObject * obj2 = 0 ;
16271 char *kwnames[] = {
16272 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16273 };
16274
16275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16277 if (SWIG_arg_fail(1)) SWIG_fail;
16278 {
16279 arg2 = (int)(SWIG_As_int(obj1));
16280 if (SWIG_arg_fail(2)) SWIG_fail;
16281 }
16282 {
16283 arg3 = (int)(SWIG_As_int(obj2));
16284 if (SWIG_arg_fail(3)) SWIG_fail;
16285 }
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 (arg1)->SetMargins(arg2,arg3);
16289
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 Py_INCREF(Py_None); resultobj = Py_None;
16294 return resultobj;
16295 fail:
16296 return NULL;
16297 }
16298
16299
16300 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16301 PyObject *resultobj;
16302 wxGrid *arg1 = (wxGrid *) 0 ;
16303 wxWindow *result;
16304 PyObject * obj0 = 0 ;
16305 char *kwnames[] = {
16306 (char *) "self", NULL
16307 };
16308
16309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16311 if (SWIG_arg_fail(1)) SWIG_fail;
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (wxWindow *)(arg1)->GetGridWindow();
16315
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 {
16320 resultobj = wxPyMake_wxObject(result, 0);
16321 }
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxGrid *arg1 = (wxGrid *) 0 ;
16331 wxWindow *result;
16332 PyObject * obj0 = 0 ;
16333 char *kwnames[] = {
16334 (char *) "self", NULL
16335 };
16336
16337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16339 if (SWIG_arg_fail(1)) SWIG_fail;
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16343
16344 wxPyEndAllowThreads(__tstate);
16345 if (PyErr_Occurred()) SWIG_fail;
16346 }
16347 {
16348 resultobj = wxPyMake_wxObject(result, 0);
16349 }
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj;
16358 wxGrid *arg1 = (wxGrid *) 0 ;
16359 wxWindow *result;
16360 PyObject * obj0 = 0 ;
16361 char *kwnames[] = {
16362 (char *) "self", NULL
16363 };
16364
16365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16367 if (SWIG_arg_fail(1)) SWIG_fail;
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16371
16372 wxPyEndAllowThreads(__tstate);
16373 if (PyErr_Occurred()) SWIG_fail;
16374 }
16375 {
16376 resultobj = wxPyMake_wxObject(result, 0);
16377 }
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj;
16386 wxGrid *arg1 = (wxGrid *) 0 ;
16387 wxWindow *result;
16388 PyObject * obj0 = 0 ;
16389 char *kwnames[] = {
16390 (char *) "self", NULL
16391 };
16392
16393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16395 if (SWIG_arg_fail(1)) SWIG_fail;
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16399
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = wxPyMake_wxObject(result, 0);
16405 }
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16413 PyObject *resultobj;
16414 wxGrid *arg1 = (wxGrid *) 0 ;
16415 int arg2 ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 char *kwnames[] = {
16419 (char *) "self",(char *) "x", NULL
16420 };
16421
16422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16424 if (SWIG_arg_fail(1)) SWIG_fail;
16425 {
16426 arg2 = (int)(SWIG_As_int(obj1));
16427 if (SWIG_arg_fail(2)) SWIG_fail;
16428 }
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 (arg1)->SetScrollLineX(arg2);
16432
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 Py_INCREF(Py_None); resultobj = Py_None;
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj;
16445 wxGrid *arg1 = (wxGrid *) 0 ;
16446 int arg2 ;
16447 PyObject * obj0 = 0 ;
16448 PyObject * obj1 = 0 ;
16449 char *kwnames[] = {
16450 (char *) "self",(char *) "y", NULL
16451 };
16452
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 {
16457 arg2 = (int)(SWIG_As_int(obj1));
16458 if (SWIG_arg_fail(2)) SWIG_fail;
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 (arg1)->SetScrollLineY(arg2);
16463
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 Py_INCREF(Py_None); resultobj = Py_None;
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxGrid *arg1 = (wxGrid *) 0 ;
16477 int result;
16478 PyObject * obj0 = 0 ;
16479 char *kwnames[] = {
16480 (char *) "self", NULL
16481 };
16482
16483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16485 if (SWIG_arg_fail(1)) SWIG_fail;
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16489
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 {
16494 resultobj = SWIG_From_int((int)(result));
16495 }
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj;
16504 wxGrid *arg1 = (wxGrid *) 0 ;
16505 int result;
16506 PyObject * obj0 = 0 ;
16507 char *kwnames[] = {
16508 (char *) "self", NULL
16509 };
16510
16511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16513 if (SWIG_arg_fail(1)) SWIG_fail;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 {
16522 resultobj = SWIG_From_int((int)(result));
16523 }
16524 return resultobj;
16525 fail:
16526 return NULL;
16527 }
16528
16529
16530 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16531 PyObject *resultobj;
16532 wxGrid *arg1 = (wxGrid *) 0 ;
16533 int arg2 ;
16534 int result;
16535 PyObject * obj0 = 0 ;
16536 PyObject * obj1 = 0 ;
16537 char *kwnames[] = {
16538 (char *) "self",(char *) "x", NULL
16539 };
16540
16541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16543 if (SWIG_arg_fail(1)) SWIG_fail;
16544 {
16545 arg2 = (int)(SWIG_As_int(obj1));
16546 if (SWIG_arg_fail(2)) SWIG_fail;
16547 }
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16551
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 {
16556 resultobj = SWIG_From_int((int)(result));
16557 }
16558 return resultobj;
16559 fail:
16560 return NULL;
16561 }
16562
16563
16564 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16565 PyObject *resultobj;
16566 wxGrid *arg1 = (wxGrid *) 0 ;
16567 int arg2 ;
16568 int result;
16569 PyObject * obj0 = 0 ;
16570 PyObject * obj1 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "self",(char *) "y", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 arg2 = (int)(SWIG_As_int(obj1));
16580 if (SWIG_arg_fail(2)) SWIG_fail;
16581 }
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = SWIG_From_int((int)(result));
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16601 wxVisualAttributes result;
16602 PyObject * obj0 = 0 ;
16603 char *kwnames[] = {
16604 (char *) "variant", NULL
16605 };
16606
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16608 if (obj0) {
16609 {
16610 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 }
16613 }
16614 {
16615 if (!wxPyCheckForApp()) SWIG_fail;
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 result = wxGrid::GetClassDefaultAttributes((wxWindowVariant )arg1);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 {
16623 wxVisualAttributes * resultptr;
16624 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16626 }
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16634 PyObject *obj;
16635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16636 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16637 Py_INCREF(obj);
16638 return Py_BuildValue((char *)"");
16639 }
16640 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16641 PyObject *resultobj;
16642 int arg1 ;
16643 wxEventType arg2 ;
16644 wxGrid *arg3 = (wxGrid *) 0 ;
16645 int arg4 = (int) -1 ;
16646 int arg5 = (int) -1 ;
16647 int arg6 = (int) -1 ;
16648 int arg7 = (int) -1 ;
16649 bool arg8 = (bool) true ;
16650 bool arg9 = (bool) false ;
16651 bool arg10 = (bool) false ;
16652 bool arg11 = (bool) false ;
16653 bool arg12 = (bool) false ;
16654 wxGridEvent *result;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 PyObject * obj2 = 0 ;
16658 PyObject * obj3 = 0 ;
16659 PyObject * obj4 = 0 ;
16660 PyObject * obj5 = 0 ;
16661 PyObject * obj6 = 0 ;
16662 PyObject * obj7 = 0 ;
16663 PyObject * obj8 = 0 ;
16664 PyObject * obj9 = 0 ;
16665 PyObject * obj10 = 0 ;
16666 PyObject * obj11 = 0 ;
16667 char *kwnames[] = {
16668 (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
16669 };
16670
16671 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;
16672 {
16673 arg1 = (int)(SWIG_As_int(obj0));
16674 if (SWIG_arg_fail(1)) SWIG_fail;
16675 }
16676 {
16677 arg2 = (wxEventType)(SWIG_As_int(obj1));
16678 if (SWIG_arg_fail(2)) SWIG_fail;
16679 }
16680 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16681 if (SWIG_arg_fail(3)) SWIG_fail;
16682 if (obj3) {
16683 {
16684 arg4 = (int)(SWIG_As_int(obj3));
16685 if (SWIG_arg_fail(4)) SWIG_fail;
16686 }
16687 }
16688 if (obj4) {
16689 {
16690 arg5 = (int)(SWIG_As_int(obj4));
16691 if (SWIG_arg_fail(5)) SWIG_fail;
16692 }
16693 }
16694 if (obj5) {
16695 {
16696 arg6 = (int)(SWIG_As_int(obj5));
16697 if (SWIG_arg_fail(6)) SWIG_fail;
16698 }
16699 }
16700 if (obj6) {
16701 {
16702 arg7 = (int)(SWIG_As_int(obj6));
16703 if (SWIG_arg_fail(7)) SWIG_fail;
16704 }
16705 }
16706 if (obj7) {
16707 {
16708 arg8 = (bool)(SWIG_As_bool(obj7));
16709 if (SWIG_arg_fail(8)) SWIG_fail;
16710 }
16711 }
16712 if (obj8) {
16713 {
16714 arg9 = (bool)(SWIG_As_bool(obj8));
16715 if (SWIG_arg_fail(9)) SWIG_fail;
16716 }
16717 }
16718 if (obj9) {
16719 {
16720 arg10 = (bool)(SWIG_As_bool(obj9));
16721 if (SWIG_arg_fail(10)) SWIG_fail;
16722 }
16723 }
16724 if (obj10) {
16725 {
16726 arg11 = (bool)(SWIG_As_bool(obj10));
16727 if (SWIG_arg_fail(11)) SWIG_fail;
16728 }
16729 }
16730 if (obj11) {
16731 {
16732 arg12 = (bool)(SWIG_As_bool(obj11));
16733 if (SWIG_arg_fail(12)) SWIG_fail;
16734 }
16735 }
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj;
16752 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16753 int result;
16754 PyObject * obj0 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (int)(arg1)->GetRow();
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 resultobj = SWIG_From_int((int)(result));
16771 }
16772 return resultobj;
16773 fail:
16774 return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj;
16780 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16781 int result;
16782 PyObject * obj0 = 0 ;
16783 char *kwnames[] = {
16784 (char *) "self", NULL
16785 };
16786
16787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
16788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16789 if (SWIG_arg_fail(1)) SWIG_fail;
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (int)(arg1)->GetCol();
16793
16794 wxPyEndAllowThreads(__tstate);
16795 if (PyErr_Occurred()) SWIG_fail;
16796 }
16797 {
16798 resultobj = SWIG_From_int((int)(result));
16799 }
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16809 wxPoint result;
16810 PyObject * obj0 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "self", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 result = (arg1)->GetPosition();
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 {
16826 wxPoint * resultptr;
16827 resultptr = new wxPoint((wxPoint &)(result));
16828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16839 bool result;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (bool)(arg1)->Selecting();
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16857 }
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16867 bool result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (bool)(arg1)->ControlDown();
16879
16880 wxPyEndAllowThreads(__tstate);
16881 if (PyErr_Occurred()) SWIG_fail;
16882 }
16883 {
16884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16885 }
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj;
16894 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16895 bool result;
16896 PyObject * obj0 = 0 ;
16897 char *kwnames[] = {
16898 (char *) "self", NULL
16899 };
16900
16901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
16902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16903 if (SWIG_arg_fail(1)) SWIG_fail;
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (bool)(arg1)->MetaDown();
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16913 }
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16923 bool result;
16924 PyObject * obj0 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "self", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
16930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16931 if (SWIG_arg_fail(1)) SWIG_fail;
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (bool)(arg1)->ShiftDown();
16935
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16951 bool result;
16952 PyObject * obj0 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 {
16961 PyThreadState* __tstate = wxPyBeginAllowThreads();
16962 result = (bool)(arg1)->AltDown();
16963
16964 wxPyEndAllowThreads(__tstate);
16965 if (PyErr_Occurred()) SWIG_fail;
16966 }
16967 {
16968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16969 }
16970 return resultobj;
16971 fail:
16972 return NULL;
16973 }
16974
16975
16976 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
16977 PyObject *obj;
16978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16979 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
16980 Py_INCREF(obj);
16981 return Py_BuildValue((char *)"");
16982 }
16983 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 int arg1 ;
16986 wxEventType arg2 ;
16987 wxGrid *arg3 = (wxGrid *) 0 ;
16988 int arg4 = (int) -1 ;
16989 int arg5 = (int) -1 ;
16990 int arg6 = (int) -1 ;
16991 bool arg7 = (bool) false ;
16992 bool arg8 = (bool) false ;
16993 bool arg9 = (bool) false ;
16994 bool arg10 = (bool) false ;
16995 wxGridSizeEvent *result;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 PyObject * obj2 = 0 ;
16999 PyObject * obj3 = 0 ;
17000 PyObject * obj4 = 0 ;
17001 PyObject * obj5 = 0 ;
17002 PyObject * obj6 = 0 ;
17003 PyObject * obj7 = 0 ;
17004 PyObject * obj8 = 0 ;
17005 PyObject * obj9 = 0 ;
17006 char *kwnames[] = {
17007 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17008 };
17009
17010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17011 {
17012 arg1 = (int)(SWIG_As_int(obj0));
17013 if (SWIG_arg_fail(1)) SWIG_fail;
17014 }
17015 {
17016 arg2 = (wxEventType)(SWIG_As_int(obj1));
17017 if (SWIG_arg_fail(2)) SWIG_fail;
17018 }
17019 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(3)) SWIG_fail;
17021 if (obj3) {
17022 {
17023 arg4 = (int)(SWIG_As_int(obj3));
17024 if (SWIG_arg_fail(4)) SWIG_fail;
17025 }
17026 }
17027 if (obj4) {
17028 {
17029 arg5 = (int)(SWIG_As_int(obj4));
17030 if (SWIG_arg_fail(5)) SWIG_fail;
17031 }
17032 }
17033 if (obj5) {
17034 {
17035 arg6 = (int)(SWIG_As_int(obj5));
17036 if (SWIG_arg_fail(6)) SWIG_fail;
17037 }
17038 }
17039 if (obj6) {
17040 {
17041 arg7 = (bool)(SWIG_As_bool(obj6));
17042 if (SWIG_arg_fail(7)) SWIG_fail;
17043 }
17044 }
17045 if (obj7) {
17046 {
17047 arg8 = (bool)(SWIG_As_bool(obj7));
17048 if (SWIG_arg_fail(8)) SWIG_fail;
17049 }
17050 }
17051 if (obj8) {
17052 {
17053 arg9 = (bool)(SWIG_As_bool(obj8));
17054 if (SWIG_arg_fail(9)) SWIG_fail;
17055 }
17056 }
17057 if (obj9) {
17058 {
17059 arg10 = (bool)(SWIG_As_bool(obj9));
17060 if (SWIG_arg_fail(10)) SWIG_fail;
17061 }
17062 }
17063 {
17064 PyThreadState* __tstate = wxPyBeginAllowThreads();
17065 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17066
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17071 return resultobj;
17072 fail:
17073 return NULL;
17074 }
17075
17076
17077 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj;
17079 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17080 int result;
17081 PyObject * obj0 = 0 ;
17082 char *kwnames[] = {
17083 (char *) "self", NULL
17084 };
17085
17086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17088 if (SWIG_arg_fail(1)) SWIG_fail;
17089 {
17090 PyThreadState* __tstate = wxPyBeginAllowThreads();
17091 result = (int)(arg1)->GetRowOrCol();
17092
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 {
17097 resultobj = SWIG_From_int((int)(result));
17098 }
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj;
17107 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17108 wxPoint result;
17109 PyObject * obj0 = 0 ;
17110 char *kwnames[] = {
17111 (char *) "self", NULL
17112 };
17113
17114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17116 if (SWIG_arg_fail(1)) SWIG_fail;
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (arg1)->GetPosition();
17120
17121 wxPyEndAllowThreads(__tstate);
17122 if (PyErr_Occurred()) SWIG_fail;
17123 }
17124 {
17125 wxPoint * resultptr;
17126 resultptr = new wxPoint((wxPoint &)(result));
17127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17128 }
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17138 bool result;
17139 PyObject * obj0 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 {
17148 PyThreadState* __tstate = wxPyBeginAllowThreads();
17149 result = (bool)(arg1)->ControlDown();
17150
17151 wxPyEndAllowThreads(__tstate);
17152 if (PyErr_Occurred()) SWIG_fail;
17153 }
17154 {
17155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17156 }
17157 return resultobj;
17158 fail:
17159 return NULL;
17160 }
17161
17162
17163 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17164 PyObject *resultobj;
17165 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17166 bool result;
17167 PyObject * obj0 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "self", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (bool)(arg1)->MetaDown();
17178
17179 wxPyEndAllowThreads(__tstate);
17180 if (PyErr_Occurred()) SWIG_fail;
17181 }
17182 {
17183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17184 }
17185 return resultobj;
17186 fail:
17187 return NULL;
17188 }
17189
17190
17191 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17192 PyObject *resultobj;
17193 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17194 bool result;
17195 PyObject * obj0 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (bool)(arg1)->ShiftDown();
17206
17207 wxPyEndAllowThreads(__tstate);
17208 if (PyErr_Occurred()) SWIG_fail;
17209 }
17210 {
17211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17212 }
17213 return resultobj;
17214 fail:
17215 return NULL;
17216 }
17217
17218
17219 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17220 PyObject *resultobj;
17221 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17222 bool result;
17223 PyObject * obj0 = 0 ;
17224 char *kwnames[] = {
17225 (char *) "self", NULL
17226 };
17227
17228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17230 if (SWIG_arg_fail(1)) SWIG_fail;
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (bool)(arg1)->AltDown();
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 {
17239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17240 }
17241 return resultobj;
17242 fail:
17243 return NULL;
17244 }
17245
17246
17247 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17248 PyObject *obj;
17249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17250 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17251 Py_INCREF(obj);
17252 return Py_BuildValue((char *)"");
17253 }
17254 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 int arg1 ;
17257 wxEventType arg2 ;
17258 wxGrid *arg3 = (wxGrid *) 0 ;
17259 wxGridCellCoords *arg4 = 0 ;
17260 wxGridCellCoords *arg5 = 0 ;
17261 bool arg6 = (bool) true ;
17262 bool arg7 = (bool) false ;
17263 bool arg8 = (bool) false ;
17264 bool arg9 = (bool) false ;
17265 bool arg10 = (bool) false ;
17266 wxGridRangeSelectEvent *result;
17267 wxGridCellCoords temp4 ;
17268 wxGridCellCoords temp5 ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 PyObject * obj2 = 0 ;
17272 PyObject * obj3 = 0 ;
17273 PyObject * obj4 = 0 ;
17274 PyObject * obj5 = 0 ;
17275 PyObject * obj6 = 0 ;
17276 PyObject * obj7 = 0 ;
17277 PyObject * obj8 = 0 ;
17278 PyObject * obj9 = 0 ;
17279 char *kwnames[] = {
17280 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17281 };
17282
17283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17284 {
17285 arg1 = (int)(SWIG_As_int(obj0));
17286 if (SWIG_arg_fail(1)) SWIG_fail;
17287 }
17288 {
17289 arg2 = (wxEventType)(SWIG_As_int(obj1));
17290 if (SWIG_arg_fail(2)) SWIG_fail;
17291 }
17292 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(3)) SWIG_fail;
17294 {
17295 arg4 = &temp4;
17296 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17297 }
17298 {
17299 arg5 = &temp5;
17300 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17301 }
17302 if (obj5) {
17303 {
17304 arg6 = (bool)(SWIG_As_bool(obj5));
17305 if (SWIG_arg_fail(6)) SWIG_fail;
17306 }
17307 }
17308 if (obj6) {
17309 {
17310 arg7 = (bool)(SWIG_As_bool(obj6));
17311 if (SWIG_arg_fail(7)) SWIG_fail;
17312 }
17313 }
17314 if (obj7) {
17315 {
17316 arg8 = (bool)(SWIG_As_bool(obj7));
17317 if (SWIG_arg_fail(8)) SWIG_fail;
17318 }
17319 }
17320 if (obj8) {
17321 {
17322 arg9 = (bool)(SWIG_As_bool(obj8));
17323 if (SWIG_arg_fail(9)) SWIG_fail;
17324 }
17325 }
17326 if (obj9) {
17327 {
17328 arg10 = (bool)(SWIG_As_bool(obj9));
17329 if (SWIG_arg_fail(10)) SWIG_fail;
17330 }
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17335
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj;
17348 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17349 wxGridCellCoords result;
17350 PyObject * obj0 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 result = (arg1)->GetTopLeftCoords();
17361
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 {
17366 wxGridCellCoords * resultptr;
17367 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17369 }
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj;
17378 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17379 wxGridCellCoords result;
17380 PyObject * obj0 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 PyThreadState* __tstate = wxPyBeginAllowThreads();
17390 result = (arg1)->GetBottomRightCoords();
17391
17392 wxPyEndAllowThreads(__tstate);
17393 if (PyErr_Occurred()) SWIG_fail;
17394 }
17395 {
17396 wxGridCellCoords * resultptr;
17397 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17399 }
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj;
17408 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17409 int result;
17410 PyObject * obj0 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (int)(arg1)->GetTopRow();
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = SWIG_From_int((int)(result));
17427 }
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj;
17436 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17437 int result;
17438 PyObject * obj0 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (int)(arg1)->GetBottomRow();
17449
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 {
17454 resultobj = SWIG_From_int((int)(result));
17455 }
17456 return resultobj;
17457 fail:
17458 return NULL;
17459 }
17460
17461
17462 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17463 PyObject *resultobj;
17464 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17465 int result;
17466 PyObject * obj0 = 0 ;
17467 char *kwnames[] = {
17468 (char *) "self", NULL
17469 };
17470
17471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17473 if (SWIG_arg_fail(1)) SWIG_fail;
17474 {
17475 PyThreadState* __tstate = wxPyBeginAllowThreads();
17476 result = (int)(arg1)->GetLeftCol();
17477
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 {
17482 resultobj = SWIG_From_int((int)(result));
17483 }
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj;
17492 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17493 int result;
17494 PyObject * obj0 = 0 ;
17495 char *kwnames[] = {
17496 (char *) "self", NULL
17497 };
17498
17499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17501 if (SWIG_arg_fail(1)) SWIG_fail;
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (int)(arg1)->GetRightCol();
17505
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 {
17510 resultobj = SWIG_From_int((int)(result));
17511 }
17512 return resultobj;
17513 fail:
17514 return NULL;
17515 }
17516
17517
17518 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj;
17520 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17521 bool result;
17522 PyObject * obj0 = 0 ;
17523 char *kwnames[] = {
17524 (char *) "self", NULL
17525 };
17526
17527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17529 if (SWIG_arg_fail(1)) SWIG_fail;
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (bool)(arg1)->Selecting();
17533
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 {
17538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17539 }
17540 return resultobj;
17541 fail:
17542 return NULL;
17543 }
17544
17545
17546 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17547 PyObject *resultobj;
17548 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17549 bool result;
17550 PyObject * obj0 = 0 ;
17551 char *kwnames[] = {
17552 (char *) "self", NULL
17553 };
17554
17555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17557 if (SWIG_arg_fail(1)) SWIG_fail;
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 result = (bool)(arg1)->ControlDown();
17561
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 {
17566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17567 }
17568 return resultobj;
17569 fail:
17570 return NULL;
17571 }
17572
17573
17574 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17575 PyObject *resultobj;
17576 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17577 bool result;
17578 PyObject * obj0 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (bool)(arg1)->MetaDown();
17589
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 {
17594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17595 }
17596 return resultobj;
17597 fail:
17598 return NULL;
17599 }
17600
17601
17602 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17603 PyObject *resultobj;
17604 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17605 bool result;
17606 PyObject * obj0 = 0 ;
17607 char *kwnames[] = {
17608 (char *) "self", NULL
17609 };
17610
17611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17613 if (SWIG_arg_fail(1)) SWIG_fail;
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (bool)(arg1)->ShiftDown();
17617
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 {
17622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17623 }
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj;
17632 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17633 bool result;
17634 PyObject * obj0 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 {
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 result = (bool)(arg1)->AltDown();
17645
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17651 }
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17659 PyObject *obj;
17660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17661 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17662 Py_INCREF(obj);
17663 return Py_BuildValue((char *)"");
17664 }
17665 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 int arg1 ;
17668 wxEventType arg2 ;
17669 wxObject *arg3 = (wxObject *) 0 ;
17670 int arg4 ;
17671 int arg5 ;
17672 wxControl *arg6 = (wxControl *) 0 ;
17673 wxGridEditorCreatedEvent *result;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 PyObject * obj2 = 0 ;
17677 PyObject * obj3 = 0 ;
17678 PyObject * obj4 = 0 ;
17679 PyObject * obj5 = 0 ;
17680 char *kwnames[] = {
17681 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17682 };
17683
17684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17685 {
17686 arg1 = (int)(SWIG_As_int(obj0));
17687 if (SWIG_arg_fail(1)) SWIG_fail;
17688 }
17689 {
17690 arg2 = (wxEventType)(SWIG_As_int(obj1));
17691 if (SWIG_arg_fail(2)) SWIG_fail;
17692 }
17693 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17694 if (SWIG_arg_fail(3)) SWIG_fail;
17695 {
17696 arg4 = (int)(SWIG_As_int(obj3));
17697 if (SWIG_arg_fail(4)) SWIG_fail;
17698 }
17699 {
17700 arg5 = (int)(SWIG_As_int(obj4));
17701 if (SWIG_arg_fail(5)) SWIG_fail;
17702 }
17703 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17704 if (SWIG_arg_fail(6)) SWIG_fail;
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17708
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj;
17721 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17722 int result;
17723 PyObject * obj0 = 0 ;
17724 char *kwnames[] = {
17725 (char *) "self", NULL
17726 };
17727
17728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17730 if (SWIG_arg_fail(1)) SWIG_fail;
17731 {
17732 PyThreadState* __tstate = wxPyBeginAllowThreads();
17733 result = (int)(arg1)->GetRow();
17734
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 {
17739 resultobj = SWIG_From_int((int)(result));
17740 }
17741 return resultobj;
17742 fail:
17743 return NULL;
17744 }
17745
17746
17747 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17748 PyObject *resultobj;
17749 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17750 int result;
17751 PyObject * obj0 = 0 ;
17752 char *kwnames[] = {
17753 (char *) "self", NULL
17754 };
17755
17756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17758 if (SWIG_arg_fail(1)) SWIG_fail;
17759 {
17760 PyThreadState* __tstate = wxPyBeginAllowThreads();
17761 result = (int)(arg1)->GetCol();
17762
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 resultobj = SWIG_From_int((int)(result));
17768 }
17769 return resultobj;
17770 fail:
17771 return NULL;
17772 }
17773
17774
17775 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17776 PyObject *resultobj;
17777 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17778 wxControl *result;
17779 PyObject * obj0 = 0 ;
17780 char *kwnames[] = {
17781 (char *) "self", NULL
17782 };
17783
17784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
17785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17786 if (SWIG_arg_fail(1)) SWIG_fail;
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 result = (wxControl *)(arg1)->GetControl();
17790
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 {
17795 resultobj = wxPyMake_wxObject(result, 0);
17796 }
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17804 PyObject *resultobj;
17805 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17806 int arg2 ;
17807 PyObject * obj0 = 0 ;
17808 PyObject * obj1 = 0 ;
17809 char *kwnames[] = {
17810 (char *) "self",(char *) "row", NULL
17811 };
17812
17813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
17814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 {
17817 arg2 = (int)(SWIG_As_int(obj1));
17818 if (SWIG_arg_fail(2)) SWIG_fail;
17819 }
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 (arg1)->SetRow(arg2);
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 Py_INCREF(Py_None); resultobj = Py_None;
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj;
17836 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17837 int arg2 ;
17838 PyObject * obj0 = 0 ;
17839 PyObject * obj1 = 0 ;
17840 char *kwnames[] = {
17841 (char *) "self",(char *) "col", NULL
17842 };
17843
17844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
17845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17846 if (SWIG_arg_fail(1)) SWIG_fail;
17847 {
17848 arg2 = (int)(SWIG_As_int(obj1));
17849 if (SWIG_arg_fail(2)) SWIG_fail;
17850 }
17851 {
17852 PyThreadState* __tstate = wxPyBeginAllowThreads();
17853 (arg1)->SetCol(arg2);
17854
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 Py_INCREF(Py_None); resultobj = Py_None;
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17868 wxControl *arg2 = (wxControl *) 0 ;
17869 PyObject * obj0 = 0 ;
17870 PyObject * obj1 = 0 ;
17871 char *kwnames[] = {
17872 (char *) "self",(char *) "ctrl", NULL
17873 };
17874
17875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
17876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17877 if (SWIG_arg_fail(1)) SWIG_fail;
17878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(2)) SWIG_fail;
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 (arg1)->SetControl(arg2);
17883
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 Py_INCREF(Py_None); resultobj = Py_None;
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
17895 PyObject *obj;
17896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17897 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
17898 Py_INCREF(obj);
17899 return Py_BuildValue((char *)"");
17900 }
17901 static PyMethodDef SwigMethods[] = {
17902 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17903 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17904 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17905 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17906 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
17907 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
17908 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17909 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
17910 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17911 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17912 { (char *)"PyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17913 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
17914 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17915 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
17916 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17917 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
17918 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17919 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17920 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17921 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17922 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17923 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
17924 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17925 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
17926 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17927 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
17928 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17929 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
17930 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17931 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
17932 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17933 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
17934 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17935 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17936 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17937 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17938 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17939 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17940 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17941 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
17942 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17943 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17944 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
17945 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17946 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17947 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17948 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17949 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17950 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17951 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17952 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17953 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17954 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
17955 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17956 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17957 { (char *)"PyGridCellEditor_base_SetSize", (PyCFunction) _wrap_PyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17958 { (char *)"PyGridCellEditor_base_Show", (PyCFunction) _wrap_PyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17959 { (char *)"PyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17960 { (char *)"PyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17961 { (char *)"PyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17962 { (char *)"PyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17963 { (char *)"PyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17964 { (char *)"PyGridCellEditor_base_Destroy", (PyCFunction) _wrap_PyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17965 { (char *)"PyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17966 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
17967 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17968 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17969 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
17970 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17971 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17972 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
17973 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17974 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17975 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
17976 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17977 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17978 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
17979 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17980 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17981 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
17982 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17983 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17984 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
17985 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17986 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17987 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
17988 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17989 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17990 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17991 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
17992 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17993 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17994 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
17995 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
17996 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
17997 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
17998 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17999 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18000 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18001 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18002 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18003 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18004 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18005 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18006 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18007 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18008 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18009 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18010 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18011 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18012 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18013 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18014 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18015 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18016 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18017 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18018 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18019 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18020 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18021 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18022 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18023 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18024 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18025 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18026 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18027 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18028 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18029 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18030 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18031 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18032 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18033 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18034 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18035 { (char *)"PyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18036 { (char *)"PyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18037 { (char *)"PyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18038 { (char *)"PyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18039 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18040 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18041 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18042 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18043 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18044 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18045 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18046 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18047 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18048 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18049 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18050 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18051 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18052 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18053 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18054 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18055 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18056 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18057 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18058 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18059 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18060 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18061 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18062 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18063 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18064 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18065 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18066 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18067 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18068 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18069 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18070 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18071 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18072 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18073 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18074 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18075 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18076 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18077 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18078 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18079 { (char *)"PyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18080 { (char *)"PyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18081 { (char *)"PyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18082 { (char *)"PyGridTableBase_base_Clear", (PyCFunction) _wrap_PyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18083 { (char *)"PyGridTableBase_base_InsertRows", (PyCFunction) _wrap_PyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18084 { (char *)"PyGridTableBase_base_AppendRows", (PyCFunction) _wrap_PyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18085 { (char *)"PyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18086 { (char *)"PyGridTableBase_base_InsertCols", (PyCFunction) _wrap_PyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18087 { (char *)"PyGridTableBase_base_AppendCols", (PyCFunction) _wrap_PyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18088 { (char *)"PyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18089 { (char *)"PyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18090 { (char *)"PyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18091 { (char *)"PyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18092 { (char *)"PyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18093 { (char *)"PyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18094 { (char *)"PyGridTableBase_base_GetAttr", (PyCFunction) _wrap_PyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18095 { (char *)"PyGridTableBase_base_SetAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18096 { (char *)"PyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18097 { (char *)"PyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18098 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18099 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18100 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18101 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18102 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18103 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18104 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18105 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18106 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18107 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18108 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18109 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18110 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18111 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18112 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18113 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18114 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18115 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18116 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18117 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18118 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18119 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18120 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18121 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18122 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18123 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18124 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18125 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18126 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18127 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18128 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18131 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18132 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18134 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18135 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18136 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18137 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18138 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18140 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18143 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18146 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18148 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18150 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18152 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18154 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18177 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18182 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18189 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18191 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18192 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18195 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18198 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18201 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18204 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18207 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18210 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18234 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18246 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18255 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18257 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18259 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18262 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18270 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18281 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18298 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18321 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18323 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18325 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18328 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18329 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18334 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18335 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18338 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18339 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18343 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18345 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18346 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18347 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18348 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18356 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18358 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18359 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18360 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18364 { NULL, NULL, 0, NULL }
18365 };
18366
18367
18368 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18369
18370 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18371 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18372 }
18373 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18374 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18375 }
18376 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18377 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18378 }
18379 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18380 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18381 }
18382 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18383 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18384 }
18385 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18386 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18387 }
18388 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18389 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18390 }
18391 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18392 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18393 }
18394 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18395 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18396 }
18397 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18398 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18399 }
18400 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18401 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18402 }
18403 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18404 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18405 }
18406 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18407 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18408 }
18409 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18410 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18411 }
18412 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18413 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18414 }
18415 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18416 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18417 }
18418 static void *_p_wxGridTo_p_wxPanel(void *x) {
18419 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18420 }
18421 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18422 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18423 }
18424 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18425 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18426 }
18427 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18428 return (void *)((wxPanel *) ((wxPyPanel *) x));
18429 }
18430 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18431 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18432 }
18433 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18434 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18435 }
18436 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18437 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18438 }
18439 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18440 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18441 }
18442 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18443 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18444 }
18445 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18446 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18447 }
18448 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18449 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18450 }
18451 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18452 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18453 }
18454 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18455 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18456 }
18457 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18458 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18459 }
18460 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18461 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18462 }
18463 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18464 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18465 }
18466 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18467 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18468 }
18469 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18470 return (void *)((wxWindow *) ((wxMenuBar *) x));
18471 }
18472 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18473 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18474 }
18475 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18476 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18477 }
18478 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18479 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18480 }
18481 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18482 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18483 }
18484 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18485 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18486 }
18487 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18488 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18489 }
18490 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18491 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18492 }
18493 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18494 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18495 }
18496 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18497 return (void *)((wxWindow *) ((wxPanel *) x));
18498 }
18499 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18500 return (void *)((wxWindow *) ((wxStatusBar *) x));
18501 }
18502 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18503 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18504 }
18505 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18506 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18507 }
18508 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18509 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18510 }
18511 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18512 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18513 }
18514 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18515 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18516 }
18517 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18518 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18519 }
18520 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18521 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18522 }
18523 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18524 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18525 }
18526 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18527 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18528 }
18529 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18530 return (void *)((wxWindow *) ((wxSashWindow *) x));
18531 }
18532 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18533 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18534 }
18535 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18536 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18537 }
18538 static void *_p_wxControlTo_p_wxWindow(void *x) {
18539 return (void *)((wxWindow *) ((wxControl *) x));
18540 }
18541 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18542 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18543 }
18544 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18545 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18546 }
18547 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18548 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18549 }
18550 static void *_p_wxGridTo_p_wxWindow(void *x) {
18551 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18552 }
18553 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18554 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18555 }
18556 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18557 return (void *)((wxWindow *) ((wxPyWindow *) x));
18558 }
18559 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18560 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18561 }
18562 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18563 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18564 }
18565 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18566 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18567 }
18568 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18569 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18570 }
18571 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18572 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18573 }
18574 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18575 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18576 }
18577 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18578 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18579 }
18580 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18581 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18582 }
18583 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18584 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18585 }
18586 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18587 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18588 }
18589 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18590 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18591 }
18592 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18593 return (void *)((wxControl *) ((wxControlWithItems *) x));
18594 }
18595 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18596 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18597 }
18598 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18599 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18600 }
18601 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18602 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18603 }
18604 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18605 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18606 }
18607 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18608 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18609 }
18610 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18611 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18612 }
18613 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18614 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18615 }
18616 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18617 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18618 }
18619 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18620 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18621 }
18622 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18623 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18624 }
18625 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18626 return (void *)((wxEvent *) ((wxPyEvent *) x));
18627 }
18628 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18629 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18630 }
18631 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18632 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18633 }
18634 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18635 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18636 }
18637 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18638 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18639 }
18640 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18641 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18642 }
18643 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18644 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18645 }
18646 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18647 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18648 }
18649 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18650 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18651 }
18652 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18653 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18654 }
18655 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18656 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18657 }
18658 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18659 return (void *)((wxEvent *) ((wxMoveEvent *) x));
18660 }
18661 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
18662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
18663 }
18664 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
18665 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18666 }
18667 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
18668 return (void *)((wxEvent *) ((wxPaintEvent *) x));
18669 }
18670 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
18671 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
18672 }
18673 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
18674 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
18675 }
18676 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
18677 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
18678 }
18679 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
18680 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
18681 }
18682 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
18683 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18684 }
18685 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
18686 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
18687 }
18688 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
18689 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18690 }
18691 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
18692 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18693 }
18694 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
18695 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
18696 }
18697 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
18698 return (void *)((wxEvent *) ((wxFocusEvent *) x));
18699 }
18700 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
18701 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
18702 }
18703 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
18704 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
18705 }
18706 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
18707 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18708 }
18709 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
18710 return (void *)((wxEvent *) ((wxShowEvent *) x));
18711 }
18712 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
18713 return (void *)((wxEvent *) ((wxCommandEvent *) x));
18714 }
18715 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
18716 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
18717 }
18718 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
18719 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
18720 }
18721 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
18722 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
18723 }
18724 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
18725 return (void *)((wxEvent *) ((wxKeyEvent *) x));
18726 }
18727 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
18728 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
18729 }
18730 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
18731 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
18732 }
18733 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
18734 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
18735 }
18736 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
18737 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18738 }
18739 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
18740 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18741 }
18742 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
18743 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18744 }
18745 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
18746 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
18747 }
18748 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
18749 return (void *)((wxObject *) ((wxSizerItem *) x));
18750 }
18751 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
18752 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
18753 }
18754 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
18755 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
18756 }
18757 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
18758 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
18759 }
18760 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
18761 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
18762 }
18763 static void *_p_wxSizerTo_p_wxObject(void *x) {
18764 return (void *)((wxObject *) ((wxSizer *) x));
18765 }
18766 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
18767 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
18768 }
18769 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
18770 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
18771 }
18772 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
18773 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
18774 }
18775 static void *_p_wxEventTo_p_wxObject(void *x) {
18776 return (void *)((wxObject *) ((wxEvent *) x));
18777 }
18778 static void *_p_wxFontDataTo_p_wxObject(void *x) {
18779 return (void *)((wxObject *) ((wxFontData *) x));
18780 }
18781 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
18782 return (void *)((wxObject *) ((wxPrintData *) x));
18783 }
18784 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
18785 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
18786 }
18787 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
18788 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
18789 }
18790 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
18791 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
18792 }
18793 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
18794 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
18795 }
18796 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
18797 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
18798 }
18799 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
18800 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
18801 }
18802 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
18803 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
18804 }
18805 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
18806 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
18807 }
18808 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
18809 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
18810 }
18811 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
18812 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
18813 }
18814 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
18815 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
18816 }
18817 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
18818 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18819 }
18820 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
18821 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
18822 }
18823 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
18824 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18825 }
18826 static void *_p_wxGridEventTo_p_wxObject(void *x) {
18827 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18828 }
18829 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
18830 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18831 }
18832 static void *_p_wxControlTo_p_wxObject(void *x) {
18833 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
18834 }
18835 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
18836 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
18837 }
18838 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
18839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18840 }
18841 static void *_p_wxFSFileTo_p_wxObject(void *x) {
18842 return (void *)((wxObject *) ((wxFSFile *) x));
18843 }
18844 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
18845 return (void *)((wxObject *) ((wxFindReplaceData *) x));
18846 }
18847 static void *_p_wxGridTo_p_wxObject(void *x) {
18848 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18849 }
18850 static void *_p_wxPySizerTo_p_wxObject(void *x) {
18851 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
18852 }
18853 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
18854 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18855 }
18856 static void *_p_wxColourDataTo_p_wxObject(void *x) {
18857 return (void *)((wxObject *) ((wxColourData *) x));
18858 }
18859 static void *_p_wxPyEventTo_p_wxObject(void *x) {
18860 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
18861 }
18862 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
18863 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
18864 }
18865 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
18866 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
18867 }
18868 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
18869 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18870 }
18871 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
18872 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18873 }
18874 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
18875 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18876 }
18877 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
18878 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18879 }
18880 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
18881 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18882 }
18883 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
18884 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18885 }
18886 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
18887 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18888 }
18889 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
18890 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18891 }
18892 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
18893 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18894 }
18895 static void *_p_wxShowEventTo_p_wxObject(void *x) {
18896 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
18897 }
18898 static void *_p_wxPrinterTo_p_wxObject(void *x) {
18899 return (void *)((wxObject *) ((wxPrinter *) x));
18900 }
18901 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
18902 return (void *)((wxObject *) ((wxMenuItem *) x));
18903 }
18904 static void *_p_wxDateEventTo_p_wxObject(void *x) {
18905 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
18906 }
18907 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
18908 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
18909 }
18910 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
18911 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
18912 }
18913 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
18914 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
18915 }
18916 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
18917 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
18918 }
18919 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
18920 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
18921 }
18922 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
18923 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
18924 }
18925 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
18926 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
18927 }
18928 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
18929 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
18930 }
18931 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
18932 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18933 }
18934 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
18935 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
18936 }
18937 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
18938 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
18939 }
18940 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
18941 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
18942 }
18943 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
18944 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
18945 }
18946 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
18947 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
18948 }
18949 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
18950 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
18951 }
18952 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
18953 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
18954 }
18955 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
18956 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
18957 }
18958 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
18959 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
18960 }
18961 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
18962 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
18963 }
18964 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
18965 return (void *)((wxObject *) ((wxImageHandler *) x));
18966 }
18967 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
18968 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
18969 }
18970 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
18971 return (void *)((wxObject *) ((wxEvtHandler *) x));
18972 }
18973 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
18974 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
18975 }
18976 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
18977 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18978 }
18979 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
18980 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18981 }
18982 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
18983 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18984 }
18985 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
18986 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
18987 }
18988 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
18989 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
18990 }
18991 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
18992 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18993 }
18994 static void *_p_wxImageTo_p_wxObject(void *x) {
18995 return (void *)((wxObject *) ((wxImage *) x));
18996 }
18997 static void *_p_wxFrameTo_p_wxObject(void *x) {
18998 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
18999 }
19000 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
19001 return (void *)((wxObject *) ((wxPyPrintout *) x));
19002 }
19003 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19004 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19005 }
19006 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19007 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19008 }
19009 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19010 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19011 }
19012 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19013 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19014 }
19015 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19016 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19017 }
19018 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19019 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19020 }
19021 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19022 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19023 }
19024 static void *_p_wxWindowTo_p_wxObject(void *x) {
19025 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19026 }
19027 static void *_p_wxMenuTo_p_wxObject(void *x) {
19028 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19029 }
19030 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19031 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19032 }
19033 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19034 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19035 }
19036 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19037 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19038 }
19039 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19040 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19041 }
19042 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19043 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19044 }
19045 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19046 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19047 }
19048 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19049 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19050 }
19051 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19052 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19053 }
19054 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19055 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19056 }
19057 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19058 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19059 }
19060 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19061 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19062 }
19063 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19064 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19065 }
19066 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19067 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19068 }
19069 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19070 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19071 }
19072 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19073 return (void *)((wxObject *) ((wxPrintPreview *) x));
19074 }
19075 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19076 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19077 }
19078 static void *_p_wxPanelTo_p_wxObject(void *x) {
19079 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19080 }
19081 static void *_p_wxDialogTo_p_wxObject(void *x) {
19082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19083 }
19084 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19085 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19086 }
19087 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19088 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19089 }
19090 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19091 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19092 }
19093 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19094 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19095 }
19096 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19097 return (void *)((wxObject *) ((wxPrintDialog *) x));
19098 }
19099 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19100 return (void *)((wxObject *) ((wxFileSystem *) x));
19101 }
19102 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19103 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19104 }
19105 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19106 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19107 }
19108 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19109 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19110 }
19111 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19112 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19113 }
19114 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19115 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19116 }
19117 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19118 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19119 }
19120 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19121 return (void *)((wxObject *) ((wxGridTableBase *) x));
19122 }
19123 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19124 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19125 }
19126 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19127 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19128 }
19129 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19130 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19131 }
19132 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19133 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19134 }
19135 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19136 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19137 }
19138 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19139 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19140 }
19141 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19142 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19143 }
19144 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19145 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19146 }
19147 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19148 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19149 }
19150 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19151 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19152 }
19153 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19154 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19155 }
19156 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19157 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19158 }
19159 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19160 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19161 }
19162 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19163 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19164 }
19165 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19166 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19167 }
19168 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19169 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19170 }
19171 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19172 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19173 }
19174 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19175 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19176 }
19177 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19178 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19179 }
19180 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19181 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19182 }
19183 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19184 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19185 }
19186 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19187 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19188 }
19189 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19190 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19191 }
19192 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19193 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19194 }
19195 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19196 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19197 }
19198 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19199 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19200 }
19201 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19202 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19203 }
19204 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19205 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19206 }
19207 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19208 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19209 }
19210 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19211 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19212 }
19213 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19214 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19215 }
19216 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19217 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19218 }
19219 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19220 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19221 }
19222 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19223 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19224 }
19225 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19226 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19227 }
19228 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19229 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19230 }
19231 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19232 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19233 }
19234 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19235 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19236 }
19237 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19238 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19239 }
19240 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19241 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19242 }
19243 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19244 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19245 }
19246 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19247 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19248 }
19249 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19250 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19251 }
19252 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19253 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19254 }
19255 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19256 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19257 }
19258 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19259 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19260 }
19261 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19262 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19263 }
19264 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19265 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19266 }
19267 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19268 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19269 }
19270 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19271 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19272 }
19273 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19274 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19275 }
19276 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19277 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19278 }
19279 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19280 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19281 }
19282 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19283 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19284 }
19285 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19286 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19287 }
19288 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19289 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19290 }
19291 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19292 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19293 }
19294 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19295 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19296 }
19297 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19298 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19299 }
19300 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19301 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19302 }
19303 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19304 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19305 }
19306 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19307 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19308 }
19309 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19310 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19311 }
19312 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19313 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19314 }
19315 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19316 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19317 }
19318 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19319 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19320 }
19321 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19322 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19323 }
19324 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19325 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19326 }
19327 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19328 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19329 }
19330 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19331 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19332 }
19333 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19334 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19335 }
19336 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19337 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19338 }
19339 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19340 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19341 }
19342 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19343 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19344 }
19345 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19346 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19347 }
19348 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19349 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19350 }
19351 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19352 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19353 }
19354 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19355 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19356 }
19357 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19358 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19359 }
19360 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19361 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19362 }
19363 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19364 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19365 }
19366 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19367 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19368 }
19369 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19370 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19371 }
19372 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19373 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19374 }
19375 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
19376 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
19377 }
19378 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19379 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19380 }
19381 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19382 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19383 }
19384 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19385 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19386 }
19387 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19388 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19389 }
19390 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19391 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19392 }
19393 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19394 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19395 }
19396 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19397 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19398 }
19399 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19400 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19401 }
19402 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19403 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19404 }
19405 static swig_type_info _swigt__p_wxGridCellNumberRenderer[] = {{"_p_wxGridCellNumberRenderer", 0, "wxGridCellNumberRenderer *", 0, 0, 0, 0},{"_p_wxGridCellNumberRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19406 static swig_type_info _swigt__p_wxPyGridCellRenderer[] = {{"_p_wxPyGridCellRenderer", 0, "wxPyGridCellRenderer *", 0, 0, 0, 0},{"_p_wxPyGridCellRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19407 static swig_type_info _swigt__p_wxGridCellRenderer[] = {{"_p_wxGridCellRenderer", 0, "wxGridCellRenderer *", 0, 0, 0, 0},{"_p_wxGridCellRenderer", 0, 0, 0, 0, 0, 0},{"_p_wxPyGridCellRenderer", _p_wxPyGridCellRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellStringRenderer", _p_wxGridCellStringRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellNumberRenderer", _p_wxGridCellNumberRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellFloatRenderer", _p_wxGridCellFloatRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellDateTimeRenderer", _p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellEnumRenderer", _p_wxGridCellEnumRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringRenderer", _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellBoolRenderer", _p_wxGridCellBoolRendererTo_p_wxGridCellRenderer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19408 static swig_type_info _swigt__p_wxGridCellStringRenderer[] = {{"_p_wxGridCellStringRenderer", 0, "wxGridCellStringRenderer *", 0, 0, 0, 0},{"_p_wxGridCellStringRenderer", 0, 0, 0, 0, 0, 0},{"_p_wxGridCellNumberRenderer", _p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellFloatRenderer", _p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellDateTimeRenderer", _p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellEnumRenderer", _p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer, 0, 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringRenderer", _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19409 static swig_type_info _swigt__p_wxGridCellAttr[] = {{"_p_wxGridCellAttr", 0, "wxGridCellAttr *", 0, 0, 0, 0},{"_p_wxGridCellAttr", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19410 static swig_type_info _swigt__p_wxGridCellFloatRenderer[] = {{"_p_wxGridCellFloatRenderer", 0, "wxGridCellFloatRenderer *", 0, 0, 0, 0},{"_p_wxGridCellFloatRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19411 static swig_type_info _swigt__p_wxGridCellBoolRenderer[] = {{"_p_wxGridCellBoolRenderer", 0, "wxGridCellBoolRenderer *", 0, 0, 0, 0},{"_p_wxGridCellBoolRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19412 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer[] = {{"_p_wxGridCellDateTimeRenderer", 0, "wxGridCellDateTimeRenderer *", 0, 0, 0, 0},{"_p_wxGridCellDateTimeRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19413 static swig_type_info _swigt__p_wxGridCellEnumRenderer[] = {{"_p_wxGridCellEnumRenderer", 0, "wxGridCellEnumRenderer *", 0, 0, 0, 0},{"_p_wxGridCellEnumRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19414 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer[] = {{"_p_wxGridCellAutoWrapStringRenderer", 0, "wxGridCellAutoWrapStringRenderer *", 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringRenderer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19415 static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19416 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19417 static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t *|form_ops_t *", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19418 static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19419 static swig_type_info _swigt__p_wxGridTableMessage[] = {{"_p_wxGridTableMessage", 0, "wxGridTableMessage *", 0, 0, 0, 0},{"_p_wxGridTableMessage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19420 static swig_type_info _swigt__p_wxGrid[] = {{"_p_wxGrid", 0, "wxGrid *", 0, 0, 0, 0},{"_p_wxGrid", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19421 static swig_type_info _swigt__p_wxVisualAttributes[] = {{"_p_wxVisualAttributes", 0, "wxVisualAttributes *", 0, 0, 0, 0},{"_p_wxVisualAttributes", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19422 static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19423 static swig_type_info _swigt__p_wxPanel[] = {{"_p_wxPanel", 0, "wxPanel *", 0, 0, 0, 0},{"_p_wxPanel", 0, 0, 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19424 static swig_type_info _swigt__p_wxNotifyEvent[] = {{"_p_wxNotifyEvent", 0, "wxNotifyEvent *", 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19425 static swig_type_info _swigt__p_wxGridRangeSelectEvent[] = {{"_p_wxGridRangeSelectEvent", 0, "wxGridRangeSelectEvent *", 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19426 static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19427 static swig_type_info _swigt__p_wxGridCellCoords[] = {{"_p_wxGridCellCoords", 0, "wxGridCellCoords *", 0, 0, 0, 0},{"_p_wxGridCellCoords", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19428 static swig_type_info _swigt__p_wxScrolledWindow[] = {{"_p_wxScrolledWindow", 0, "wxScrolledWindow *", 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxScrolledWindow, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxScrolledWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxScrolledWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19429 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19430 static swig_type_info _swigt__p_wxFont[] = {{"_p_wxFont", 0, "wxFont *", 0, 0, 0, 0},{"_p_wxFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19431 static swig_type_info _swigt__p_wxControl[] = {{"_p_wxControl", 0, "wxControl *", 0, 0, 0, 0},{"_p_wxControl", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxControl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19432 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19433 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontData", _p_wxFontDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintData", _p_wxPrintDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", _p_wxPyTaskBarIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridStringTable", _p_wxGridStringTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutAlgorithm", _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceData", _p_wxFindReplaceDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourData", _p_wxColourDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinter", _p_wxPrinterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintout", _p_wxPyPrintoutTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintPreview", _p_wxPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintPreview", _p_wxPyPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialog", _p_wxPageSetupDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialog", _p_wxPrintDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridTableBase", _p_wxGridTableBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyGridTableBase", _p_wxPyGridTableBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialogData", _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialogData", _p_wxPrintDialogDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19434 static swig_type_info _swigt__p_wxGridSizeEvent[] = {{"_p_wxGridSizeEvent", 0, "wxGridSizeEvent *", 0, 0, 0, 0},{"_p_wxGridSizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19435 static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19436 static swig_type_info _swigt__p_long[] = {{"_p_long", 0, "long *", 0, 0, 0, 0},{"_p_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19437 static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize *|wxPaperSize *", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19438 static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|time_t *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19439 static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19440 static swig_type_info _swigt__p_wxString[] = {{"_p_wxString", 0, "wxString *", 0, 0, 0, 0},{"_p_wxString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19441 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19442 static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19443 static swig_type_info _swigt__p_wxGridEvent[] = {{"_p_wxGridEvent", 0, "wxGridEvent *", 0, 0, 0, 0},{"_p_wxGridEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19444 static swig_type_info _swigt__p_wxGridEditorCreatedEvent[] = {{"_p_wxGridEditorCreatedEvent", 0, "wxGridEditorCreatedEvent *", 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19445 static swig_type_info _swigt__p_wxGridTableBase[] = {{"_p_wxGridTableBase", 0, "wxGridTableBase *", 0, 0, 0, 0},{"_p_wxGridStringTable", _p_wxGridStringTableTo_p_wxGridTableBase, 0, 0, 0, 0, 0},{"_p_wxGridTableBase", 0, 0, 0, 0, 0, 0},{"_p_wxPyGridTableBase", _p_wxPyGridTableBaseTo_p_wxGridTableBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19446 static swig_type_info _swigt__p_wxGridCellEditor[] = {{"_p_wxGridCellEditor", 0, "wxGridCellEditor *", 0, 0, 0, 0},{"_p_wxGridCellEditor", 0, 0, 0, 0, 0, 0},{"_p_wxPyGridCellEditor", _p_wxPyGridCellEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellTextEditor", _p_wxGridCellTextEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellNumberEditor", _p_wxGridCellNumberEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellFloatEditor", _p_wxGridCellFloatEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellBoolEditor", _p_wxGridCellBoolEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringEditor", _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellChoiceEditor", _p_wxGridCellChoiceEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellEnumEditor", _p_wxGridCellEnumEditorTo_p_wxGridCellEditor, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19447 static swig_type_info _swigt__p_wxGridCellTextEditor[] = {{"_p_wxGridCellTextEditor", 0, "wxGridCellTextEditor *", 0, 0, 0, 0},{"_p_wxGridCellTextEditor", 0, 0, 0, 0, 0, 0},{"_p_wxGridCellNumberEditor", _p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellFloatEditor", _p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor, 0, 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringEditor", _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19448 static swig_type_info _swigt__p_wxPyGridCellEditor[] = {{"_p_wxPyGridCellEditor", 0, "wxPyGridCellEditor *", 0, 0, 0, 0},{"_p_wxPyGridCellEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19449 static swig_type_info _swigt__p_wxGridCellNumberEditor[] = {{"_p_wxGridCellNumberEditor", 0, "wxGridCellNumberEditor *", 0, 0, 0, 0},{"_p_wxGridCellNumberEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19450 static swig_type_info _swigt__p_wxGridCellFloatEditor[] = {{"_p_wxGridCellFloatEditor", 0, "wxGridCellFloatEditor *", 0, 0, 0, 0},{"_p_wxGridCellFloatEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19451 static swig_type_info _swigt__p_wxGridCellBoolEditor[] = {{"_p_wxGridCellBoolEditor", 0, "wxGridCellBoolEditor *", 0, 0, 0, 0},{"_p_wxGridCellBoolEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19452 static swig_type_info _swigt__p_wxPyGridTableBase[] = {{"_p_wxPyGridTableBase", 0, "wxPyGridTableBase *", 0, 0, 0, 0},{"_p_wxPyGridTableBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19453 static swig_type_info _swigt__p_wxGridStringTable[] = {{"_p_wxGridStringTable", 0, "wxGridStringTable *", 0, 0, 0, 0},{"_p_wxGridStringTable", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19454 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19455 static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19456 static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19457 static swig_type_info _swigt__p_wxArrayString[] = {{"_p_wxArrayString", 0, "wxArrayString *", 0, 0, 0, 0},{"_p_wxArrayString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19458 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19459 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19460 static swig_type_info _swigt__p_wxGridCellAttrProvider[] = {{"_p_wxGridCellAttrProvider", 0, "wxGridCellAttrProvider *", 0, 0, 0, 0},{"_p_wxGridCellAttrProvider", 0, 0, 0, 0, 0, 0},{"_p_wxPyGridCellAttrProvider", _p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19461 static swig_type_info _swigt__p_wxGridCellChoiceEditor[] = {{"_p_wxGridCellChoiceEditor", 0, "wxGridCellChoiceEditor *", 0, 0, 0, 0},{"_p_wxGridCellChoiceEditor", 0, 0, 0, 0, 0, 0},{"_p_wxGridCellEnumEditor", _p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19462 static swig_type_info _swigt__p_wxKeyEvent[] = {{"_p_wxKeyEvent", 0, "wxKeyEvent *", 0, 0, 0, 0},{"_p_wxKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19463 static swig_type_info _swigt__p_wxGridCellEnumEditor[] = {{"_p_wxGridCellEnumEditor", 0, "wxGridCellEnumEditor *", 0, 0, 0, 0},{"_p_wxGridCellEnumEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19464 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor[] = {{"_p_wxGridCellAutoWrapStringEditor", 0, "wxGridCellAutoWrapStringEditor *", 0, 0, 0, 0},{"_p_wxGridCellAutoWrapStringEditor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19465 static swig_type_info _swigt__p_wxPyGridCellAttrProvider[] = {{"_p_wxPyGridCellAttrProvider", 0, "wxPyGridCellAttrProvider *", 0, 0, 0, 0},{"_p_wxPyGridCellAttrProvider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19466 static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|wxUIntPtr *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19467
19468 static swig_type_info *swig_types_initial[] = {
19469 _swigt__p_wxGridCellNumberRenderer,
19470 _swigt__p_wxPyGridCellRenderer,
19471 _swigt__p_wxGridCellRenderer,
19472 _swigt__p_wxGridCellStringRenderer,
19473 _swigt__p_wxGridCellAttr,
19474 _swigt__p_wxGridCellFloatRenderer,
19475 _swigt__p_wxGridCellBoolRenderer,
19476 _swigt__p_wxGridCellDateTimeRenderer,
19477 _swigt__p_wxGridCellEnumRenderer,
19478 _swigt__p_wxGridCellAutoWrapStringRenderer,
19479 _swigt__p_wxColour,
19480 _swigt__p_wxDC,
19481 _swigt__p_form_ops_t,
19482 _swigt__p_wxDuplexMode,
19483 _swigt__p_wxGridTableMessage,
19484 _swigt__p_wxGrid,
19485 _swigt__p_wxVisualAttributes,
19486 _swigt__p_char,
19487 _swigt__p_wxPanel,
19488 _swigt__p_wxNotifyEvent,
19489 _swigt__p_wxGridRangeSelectEvent,
19490 _swigt__p_wxSize,
19491 _swigt__p_wxGridCellCoords,
19492 _swigt__p_wxScrolledWindow,
19493 _swigt__p_wxWindow,
19494 _swigt__p_wxFont,
19495 _swigt__p_wxControl,
19496 _swigt__p_wxEvent,
19497 _swigt__p_wxObject,
19498 _swigt__p_wxGridSizeEvent,
19499 _swigt__p_wxRect,
19500 _swigt__p_long,
19501 _swigt__p_wxPaperSize,
19502 _swigt__p_unsigned_int,
19503 _swigt__unsigned_int,
19504 _swigt__p_wxString,
19505 _swigt__p_wxEvtHandler,
19506 _swigt__p_wxPoint,
19507 _swigt__p_wxGridEvent,
19508 _swigt__p_wxGridEditorCreatedEvent,
19509 _swigt__p_wxGridTableBase,
19510 _swigt__p_wxGridCellEditor,
19511 _swigt__p_wxGridCellTextEditor,
19512 _swigt__p_wxPyGridCellEditor,
19513 _swigt__p_wxGridCellNumberEditor,
19514 _swigt__p_wxGridCellFloatEditor,
19515 _swigt__p_wxGridCellBoolEditor,
19516 _swigt__p_wxPyGridTableBase,
19517 _swigt__p_wxGridStringTable,
19518 _swigt__p_unsigned_char,
19519 _swigt__std__ptrdiff_t,
19520 _swigt__ptrdiff_t,
19521 _swigt__p_wxArrayString,
19522 _swigt__p_wxCommandEvent,
19523 _swigt__p_int,
19524 _swigt__p_wxGridCellAttrProvider,
19525 _swigt__p_wxGridCellChoiceEditor,
19526 _swigt__p_wxKeyEvent,
19527 _swigt__p_wxGridCellEnumEditor,
19528 _swigt__p_wxGridCellAutoWrapStringEditor,
19529 _swigt__p_wxPyGridCellAttrProvider,
19530 _swigt__p_unsigned_long,
19531 0
19532 };
19533
19534
19535 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
19536
19537 static swig_const_info swig_const_table[] = {
19538 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19539 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
19540 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19541 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
19542 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
19543 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19544 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19545 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
19546 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
19547 {0, 0, 0, 0.0, 0, 0}};
19548
19549 #ifdef __cplusplus
19550 }
19551 #endif
19552
19553
19554 #ifdef __cplusplus
19555 extern "C" {
19556 #endif
19557
19558 /* Python-specific SWIG API */
19559 #define SWIG_newvarlink() SWIG_Python_newvarlink()
19560 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
19561 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
19562
19563 /* -----------------------------------------------------------------------------
19564 * global variable support code.
19565 * ----------------------------------------------------------------------------- */
19566
19567 typedef struct swig_globalvar {
19568 char *name; /* Name of global variable */
19569 PyObject *(*get_attr)(); /* Return the current value */
19570 int (*set_attr)(PyObject *); /* Set the value */
19571 struct swig_globalvar *next;
19572 } swig_globalvar;
19573
19574 typedef struct swig_varlinkobject {
19575 PyObject_HEAD
19576 swig_globalvar *vars;
19577 } swig_varlinkobject;
19578
19579 static PyObject *
19580 swig_varlink_repr(swig_varlinkobject *v) {
19581 v = v;
19582 return PyString_FromString("<Swig global variables>");
19583 }
19584
19585 static int
19586 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
19587 swig_globalvar *var;
19588 flags = flags;
19589 fprintf(fp,"Swig global variables { ");
19590 for (var = v->vars; var; var=var->next) {
19591 fprintf(fp,"%s", var->name);
19592 if (var->next) fprintf(fp,", ");
19593 }
19594 fprintf(fp," }\n");
19595 return 0;
19596 }
19597
19598 static PyObject *
19599 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
19600 swig_globalvar *var = v->vars;
19601 while (var) {
19602 if (strcmp(var->name,n) == 0) {
19603 return (*var->get_attr)();
19604 }
19605 var = var->next;
19606 }
19607 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19608 return NULL;
19609 }
19610
19611 static int
19612 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
19613 swig_globalvar *var = v->vars;
19614 while (var) {
19615 if (strcmp(var->name,n) == 0) {
19616 return (*var->set_attr)(p);
19617 }
19618 var = var->next;
19619 }
19620 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19621 return 1;
19622 }
19623
19624 static PyTypeObject varlinktype = {
19625 PyObject_HEAD_INIT(0)
19626 0, /* Number of items in variable part (ob_size) */
19627 (char *)"swigvarlink", /* Type name (tp_name) */
19628 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
19629 0, /* Itemsize (tp_itemsize) */
19630 0, /* Deallocator (tp_dealloc) */
19631 (printfunc) swig_varlink_print, /* Print (tp_print) */
19632 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
19633 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
19634 0, /* tp_compare */
19635 (reprfunc) swig_varlink_repr, /* tp_repr */
19636 0, /* tp_as_number */
19637 0, /* tp_as_sequence */
19638 0, /* tp_as_mapping */
19639 0, /* tp_hash */
19640 0, /* tp_call */
19641 0, /* tp_str */
19642 0, /* tp_getattro */
19643 0, /* tp_setattro */
19644 0, /* tp_as_buffer */
19645 0, /* tp_flags */
19646 0, /* tp_doc */
19647 #if PY_VERSION_HEX >= 0x02000000
19648 0, /* tp_traverse */
19649 0, /* tp_clear */
19650 #endif
19651 #if PY_VERSION_HEX >= 0x02010000
19652 0, /* tp_richcompare */
19653 0, /* tp_weaklistoffset */
19654 #endif
19655 #if PY_VERSION_HEX >= 0x02020000
19656 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
19657 #endif
19658 #if PY_VERSION_HEX >= 0x02030000
19659 0, /* tp_del */
19660 #endif
19661 #ifdef COUNT_ALLOCS
19662 0,0,0,0 /* tp_alloc -> tp_next */
19663 #endif
19664 };
19665
19666 /* Create a variable linking object for use later */
19667 static PyObject *
19668 SWIG_Python_newvarlink(void) {
19669 swig_varlinkobject *result = 0;
19670 result = PyMem_NEW(swig_varlinkobject,1);
19671 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
19672 result->ob_type = &varlinktype;
19673 result->vars = 0;
19674 result->ob_refcnt = 0;
19675 Py_XINCREF((PyObject *) result);
19676 return ((PyObject*) result);
19677 }
19678
19679 static void
19680 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
19681 swig_varlinkobject *v;
19682 swig_globalvar *gv;
19683 v= (swig_varlinkobject *) p;
19684 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
19685 gv->name = (char *) malloc(strlen(name)+1);
19686 strcpy(gv->name,name);
19687 gv->get_attr = get_attr;
19688 gv->set_attr = set_attr;
19689 gv->next = v->vars;
19690 v->vars = gv;
19691 }
19692
19693 /* -----------------------------------------------------------------------------
19694 * constants/methods manipulation
19695 * ----------------------------------------------------------------------------- */
19696
19697 /* Install Constants */
19698 static void
19699 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
19700 PyObject *obj = 0;
19701 size_t i;
19702 for (i = 0; constants[i].type; i++) {
19703 switch(constants[i].type) {
19704 case SWIG_PY_INT:
19705 obj = PyInt_FromLong(constants[i].lvalue);
19706 break;
19707 case SWIG_PY_FLOAT:
19708 obj = PyFloat_FromDouble(constants[i].dvalue);
19709 break;
19710 case SWIG_PY_STRING:
19711 if (constants[i].pvalue) {
19712 obj = PyString_FromString((char *) constants[i].pvalue);
19713 } else {
19714 Py_INCREF(Py_None);
19715 obj = Py_None;
19716 }
19717 break;
19718 case SWIG_PY_POINTER:
19719 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
19720 break;
19721 case SWIG_PY_BINARY:
19722 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
19723 break;
19724 default:
19725 obj = 0;
19726 break;
19727 }
19728 if (obj) {
19729 PyDict_SetItemString(d,constants[i].name,obj);
19730 Py_DECREF(obj);
19731 }
19732 }
19733 }
19734
19735 /* -----------------------------------------------------------------------------*/
19736 /* Fix SwigMethods to carry the callback ptrs when needed */
19737 /* -----------------------------------------------------------------------------*/
19738
19739 static void
19740 SWIG_Python_FixMethods(PyMethodDef *methods,
19741 swig_const_info *const_table,
19742 swig_type_info **types,
19743 swig_type_info **types_initial) {
19744 size_t i;
19745 for (i = 0; methods[i].ml_name; ++i) {
19746 char *c = methods[i].ml_doc;
19747 if (c && (c = strstr(c, "swig_ptr: "))) {
19748 int j;
19749 swig_const_info *ci = 0;
19750 char *name = c + 10;
19751 for (j = 0; const_table[j].type; j++) {
19752 if (strncmp(const_table[j].name, name,
19753 strlen(const_table[j].name)) == 0) {
19754 ci = &(const_table[j]);
19755 break;
19756 }
19757 }
19758 if (ci) {
19759 size_t shift = (ci->ptype) - types;
19760 swig_type_info *ty = types_initial[shift];
19761 size_t ldoc = (c - methods[i].ml_doc);
19762 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
19763 char *ndoc = (char*)malloc(ldoc + lptr + 10);
19764 char *buff = ndoc;
19765 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
19766 strncpy(buff, methods[i].ml_doc, ldoc);
19767 buff += ldoc;
19768 strncpy(buff, "swig_ptr: ", 10);
19769 buff += 10;
19770 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
19771 methods[i].ml_doc = ndoc;
19772 }
19773 }
19774 }
19775 }
19776
19777 /* -----------------------------------------------------------------------------*
19778 * Initialize type list
19779 * -----------------------------------------------------------------------------*/
19780
19781 #if PY_MAJOR_VERSION < 2
19782 /* PyModule_AddObject function was introduced in Python 2.0. The following function
19783 is copied out of Python/modsupport.c in python version 2.3.4 */
19784 static int
19785 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
19786 {
19787 PyObject *dict;
19788 if (!PyModule_Check(m)) {
19789 PyErr_SetString(PyExc_TypeError,
19790 "PyModule_AddObject() needs module as first arg");
19791 return -1;
19792 }
19793 if (!o) {
19794 PyErr_SetString(PyExc_TypeError,
19795 "PyModule_AddObject() needs non-NULL value");
19796 return -1;
19797 }
19798
19799 dict = PyModule_GetDict(m);
19800 if (dict == NULL) {
19801 /* Internal error -- modules must have a dict! */
19802 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
19803 PyModule_GetName(m));
19804 return -1;
19805 }
19806 if (PyDict_SetItemString(dict, name, o))
19807 return -1;
19808 Py_DECREF(o);
19809 return 0;
19810 }
19811 #endif
19812
19813 static swig_type_info **
19814 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
19815 static PyMethodDef swig_empty_runtime_method_table[] = {
19816 {
19817 NULL, NULL, 0, NULL
19818 }
19819 };/* Sentinel */
19820
19821 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
19822 swig_empty_runtime_method_table);
19823 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
19824 if (pointer && module) {
19825 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
19826 }
19827 return type_list_handle;
19828 }
19829
19830 static swig_type_info **
19831 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
19832 swig_type_info **type_pointer;
19833
19834 /* first check if module already created */
19835 type_pointer = SWIG_Python_GetTypeListHandle();
19836 if (type_pointer) {
19837 return type_pointer;
19838 } else {
19839 /* create a new module and variable */
19840 return SWIG_Python_SetTypeListHandle(type_list_handle);
19841 }
19842 }
19843
19844 #ifdef __cplusplus
19845 }
19846 #endif
19847
19848 /* -----------------------------------------------------------------------------*
19849 * Partial Init method
19850 * -----------------------------------------------------------------------------*/
19851
19852 #ifdef SWIG_LINK_RUNTIME
19853 #ifdef __cplusplus
19854 extern "C"
19855 #endif
19856 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
19857 #endif
19858
19859 #ifdef __cplusplus
19860 extern "C"
19861 #endif
19862 SWIGEXPORT(void) SWIG_init(void) {
19863 static PyObject *SWIG_globals = 0;
19864 static int typeinit = 0;
19865 PyObject *m, *d;
19866 int i;
19867 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
19868
19869 /* Fix SwigMethods to carry the callback ptrs when needed */
19870 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
19871
19872 m = Py_InitModule((char *) SWIG_name, SwigMethods);
19873 d = PyModule_GetDict(m);
19874
19875 if (!typeinit) {
19876 #ifdef SWIG_LINK_RUNTIME
19877 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
19878 #else
19879 # ifndef SWIG_STATIC_RUNTIME
19880 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
19881 # endif
19882 #endif
19883 for (i = 0; swig_types_initial[i]; i++) {
19884 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
19885 }
19886 typeinit = 1;
19887 }
19888 SWIG_InstallConstants(d,swig_const_table);
19889
19890 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
19891 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
19892 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
19893 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
19894 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
19895 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
19896 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
19897 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
19898 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
19899 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
19900 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
19901 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
19902 {
19903 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_ROWS)));
19904 }
19905 {
19906 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_COLS)));
19907 }
19908 {
19909 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_HEIGHT)));
19910 }
19911 {
19912 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_COL_WIDTH)));
19913 }
19914 {
19915 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
19916 }
19917 {
19918 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
19919 }
19920 {
19921 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int((int)(wxGRID_LABEL_EDGE_ZONE)));
19922 }
19923 {
19924 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_MIN_ROW_HEIGHT)));
19925 }
19926 {
19927 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int((int)(wxGRID_MIN_COL_WIDTH)));
19928 }
19929 {
19930 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
19931 }
19932 {
19933 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int((int)(wxGridCellAttr::Any)));
19934 }
19935 {
19936 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int((int)(wxGridCellAttr::Default)));
19937 }
19938 {
19939 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int((int)(wxGridCellAttr::Cell)));
19940 }
19941 {
19942 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int((int)(wxGridCellAttr::Row)));
19943 }
19944 {
19945 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int((int)(wxGridCellAttr::Col)));
19946 }
19947 {
19948 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int((int)(wxGridCellAttr::Merged)));
19949 }
19950 {
19951 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
19952 }
19953 {
19954 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
19955 }
19956 {
19957 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
19958 }
19959 {
19960 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
19961 }
19962 {
19963 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
19964 }
19965 {
19966 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
19967 }
19968 {
19969 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
19970 }
19971 {
19972 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
19973 }
19974 {
19975 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int((int)(wxGrid::wxGridSelectCells)));
19976 }
19977 {
19978 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int((int)(wxGrid::wxGridSelectRows)));
19979 }
19980 {
19981 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int((int)(wxGrid::wxGridSelectColumns)));
19982 }
19983 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
19984 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
19985 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
19986 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
19987 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
19988 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
19989 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
19990 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
19991 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
19992 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
19993 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
19994 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
19995 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
19996 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
19997 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
19998 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
19999 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
20000
20001
20002 }
20003
wxWidgets (Impactor)