]> 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
reSWIGged
[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 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[0]
1342 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[1]
1343 #define SWIGTYPE_p_wxGridCellRenderer swig_types[2]
1344 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[3]
1345 #define SWIGTYPE_p_wxGridCellAttr swig_types[4]
1346 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[5]
1347 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[6]
1348 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[7]
1349 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[8]
1350 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[9]
1351 #define SWIGTYPE_p_wxColour swig_types[10]
1352 #define SWIGTYPE_p_wxDC swig_types[11]
1353 #define SWIGTYPE_p_form_ops_t swig_types[12]
1354 #define SWIGTYPE_p_wxDuplexMode swig_types[13]
1355 #define SWIGTYPE_p_wxGridTableMessage swig_types[14]
1356 #define SWIGTYPE_p_wxGrid swig_types[15]
1357 #define SWIGTYPE_p_wxVisualAttributes swig_types[16]
1358 #define SWIGTYPE_p_char swig_types[17]
1359 #define SWIGTYPE_p_wxPanel swig_types[18]
1360 #define SWIGTYPE_p_wxNotifyEvent swig_types[19]
1361 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSize swig_types[21]
1363 #define SWIGTYPE_p_wxGridCellCoords swig_types[22]
1364 #define SWIGTYPE_p_wxScrolledWindow swig_types[23]
1365 #define SWIGTYPE_p_wxWindow swig_types[24]
1366 #define SWIGTYPE_p_wxFont swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxEvent swig_types[27]
1369 #define SWIGTYPE_p_wxObject swig_types[28]
1370 #define SWIGTYPE_p_wxGridSizeEvent swig_types[29]
1371 #define SWIGTYPE_p_wxRect swig_types[30]
1372 #define SWIGTYPE_p_long swig_types[31]
1373 #define SWIGTYPE_p_wxPaperSize swig_types[32]
1374 #define SWIGTYPE_p_unsigned_int swig_types[33]
1375 #define SWIGTYPE_unsigned_int swig_types[34]
1376 #define SWIGTYPE_p_wxString swig_types[35]
1377 #define SWIGTYPE_p_wxEvtHandler swig_types[36]
1378 #define SWIGTYPE_p_wxPoint swig_types[37]
1379 #define SWIGTYPE_p_wxGridEvent swig_types[38]
1380 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[39]
1381 #define SWIGTYPE_p_wxGridTableBase swig_types[40]
1382 #define SWIGTYPE_p_wxGridCellEditor swig_types[41]
1383 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[42]
1384 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[43]
1385 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[44]
1386 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[45]
1387 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[46]
1388 #define SWIGTYPE_p_wxPyGridTableBase swig_types[47]
1389 #define SWIGTYPE_p_wxGridStringTable swig_types[48]
1390 #define SWIGTYPE_p_unsigned_char swig_types[49]
1391 #define SWIGTYPE_std__ptrdiff_t swig_types[50]
1392 #define SWIGTYPE_ptrdiff_t swig_types[51]
1393 #define SWIGTYPE_p_wxArrayString swig_types[52]
1394 #define SWIGTYPE_p_wxCommandEvent swig_types[53]
1395 #define SWIGTYPE_p_int swig_types[54]
1396 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[55]
1397 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
1398 #define SWIGTYPE_p_wxKeyEvent swig_types[57]
1399 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[58]
1400 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[59]
1401 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[60]
1402 #define SWIGTYPE_p_unsigned_long swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _grid.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_grid
1412
1413 #define SWIG_name "_grid"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417 #include "wx/wxPython/printfw.h"
1418
1419 #include <wx/grid.h>
1420 #include <wx/generic/gridctrl.h>
1421
1422
1423 static const wxString wxPyEmptyString(wxEmptyString);
1424 static const wxString wxPyPanelNameStr(wxPanelNameStr);
1425 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
1426
1427
1428 #define wxPyMake_TEMPLATE(TYPE) \
1429 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
1430 PyObject* target = NULL; \
1431 if (source) { \
1432 /* Check if there is already a pointer to a Python object in the \
1433 OOR data that we can use. */ \
1434 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
1435 if (data) { \
1436 target = data->m_obj; \
1437 if (target) \
1438 Py_INCREF(target); \
1439 } \
1440 /* Otherwise make a new wrapper for it the old fashioned way and \
1441 give it the OOR treatment */ \
1442 if (! target) { \
1443 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
1444 if (target) \
1445 source->SetClientObject(new wxPyOORClientData(target)); \
1446 } \
1447 } else { /* source was NULL so return None. */ \
1448 Py_INCREF(Py_None); target = Py_None; \
1449 } \
1450 return target; \
1451 } \
1452
1453
1454 wxPyMake_TEMPLATE(wxGridCellRenderer)
1455 wxPyMake_TEMPLATE(wxGridCellEditor)
1456 wxPyMake_TEMPLATE(wxGridCellAttr)
1457 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
1458 wxPyMake_TEMPLATE(wxGridTableBase)
1459
1460
1461
1462 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
1463 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1464 wxGridCellAttr* rval = NULL; \
1465 bool found; \
1466 bool blocked = wxPyBeginBlockThreads(); \
1467 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1468 PyObject* ro; \
1469 wxGridCellAttr* ptr; \
1470 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
1471 if (ro) { \
1472 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
1473 rval = ptr; \
1474 Py_DECREF(ro); \
1475 } \
1476 } \
1477 wxPyEndBlockThreads(blocked); \
1478 if (! found) \
1479 rval = PCLASS::CBNAME(a, b, c); \
1480 return rval; \
1481 } \
1482 wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1483 return PCLASS::CBNAME(a, b, c); \
1484 }
1485
1486
1487
1488 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
1489 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
1490 bool blocked = wxPyBeginBlockThreads(); \
1491 bool found; \
1492 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1493 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1494 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
1495 Py_DECREF(obj); \
1496 } \
1497 wxPyEndBlockThreads(blocked); \
1498 if (! found) \
1499 PCLASS::CBNAME(attr, a, b); \
1500 } \
1501 void base_##CBNAME(wxGridCellAttr *attr, int a, int b) { \
1502 PCLASS::CBNAME(attr, a, b); \
1503 }
1504
1505
1506
1507 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
1508 void CBNAME(wxGridCellAttr *attr, int val) { \
1509 bool blocked = wxPyBeginBlockThreads(); \
1510 bool found; \
1511 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1512 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1513 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
1514 Py_DECREF(obj); \
1515 } \
1516 wxPyEndBlockThreads(blocked); \
1517 if (! found) \
1518 PCLASS::CBNAME(attr, val); \
1519 } \
1520 void base_##CBNAME(wxGridCellAttr *attr, int val) { \
1521 PCLASS::CBNAME(attr, val); \
1522 }
1523
1524
1525
1526 #define PYCALLBACK_INT__pure(CBNAME) \
1527 int CBNAME() { \
1528 bool blocked = wxPyBeginBlockThreads(); \
1529 int rval = 0; \
1530 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1531 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1532 wxPyEndBlockThreads(blocked); \
1533 return rval; \
1534 }
1535
1536
1537
1538 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
1539 bool CBNAME(int a, int b) { \
1540 bool blocked = wxPyBeginBlockThreads(); \
1541 bool rval = 0; \
1542 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1543 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
1544 wxPyEndBlockThreads(blocked); \
1545 return rval; \
1546 }
1547
1548
1549 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
1550 wxString CBNAME(int a, int b) { \
1551 bool blocked = wxPyBeginBlockThreads(); \
1552 wxString rval; \
1553 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1554 PyObject* ro; \
1555 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1556 if (ro) { \
1557 rval = Py2wxString(ro); \
1558 Py_DECREF(ro); \
1559 } \
1560 } \
1561 wxPyEndBlockThreads(blocked); \
1562 return rval; \
1563 }
1564
1565
1566 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
1567 void CBNAME(int a, int b, const wxString& c) { \
1568 bool blocked = wxPyBeginBlockThreads(); \
1569 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1570 PyObject* s = wx2PyString(c); \
1571 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1572 Py_DECREF(s); \
1573 } \
1574 wxPyEndBlockThreads(blocked); \
1575 }
1576
1577
1578 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
1579 wxString CBNAME(int a, int b) { \
1580 bool found; \
1581 bool blocked = wxPyBeginBlockThreads(); \
1582 wxString rval; \
1583 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1584 PyObject* ro; \
1585 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1586 if (ro) { \
1587 rval = Py2wxString(ro); \
1588 Py_DECREF(ro); \
1589 } \
1590 } \
1591 wxPyEndBlockThreads(blocked); \
1592 if (! found) \
1593 rval = PCLASS::CBNAME(a, b); \
1594 return rval; \
1595 } \
1596 wxString base_##CBNAME(int a, int b) { \
1597 return PCLASS::CBNAME(a, b); \
1598 }
1599
1600
1601 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
1602 bool CBNAME(int a, int b, const wxString& c) { \
1603 bool rval = 0; \
1604 bool found; \
1605 bool blocked = wxPyBeginBlockThreads(); \
1606 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1607 PyObject* s = wx2PyString(c); \
1608 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1609 Py_DECREF(s); \
1610 } \
1611 wxPyEndBlockThreads(blocked); \
1612 if (! found) \
1613 rval = PCLASS::CBNAME(a,b,c); \
1614 return rval; \
1615 } \
1616 bool base_##CBNAME(int a, int b, const wxString& c) { \
1617 return PCLASS::CBNAME(a,b,c); \
1618 }
1619
1620
1621
1622
1623 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
1624 long CBNAME(int a, int b) { \
1625 long rval; \
1626 bool found; \
1627 bool blocked = wxPyBeginBlockThreads(); \
1628 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1629 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1630 wxPyEndBlockThreads(blocked); \
1631 if (! found) \
1632 rval = PCLASS::CBNAME(a,b); \
1633 return rval; \
1634 } \
1635 long base_##CBNAME(int a, int b) { \
1636 return PCLASS::CBNAME(a,b); \
1637 }
1638
1639
1640
1641 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
1642 bool CBNAME(int a, int b) { \
1643 bool rval = 0; \
1644 bool found; \
1645 bool blocked = wxPyBeginBlockThreads(); \
1646 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1647 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1648 wxPyEndBlockThreads(blocked); \
1649 if (! found) \
1650 rval = PCLASS::CBNAME(a,b); \
1651 return rval; \
1652 } \
1653 bool base_##CBNAME(int a, int b) { \
1654 return PCLASS::CBNAME(a,b); \
1655 }
1656
1657
1658
1659 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
1660 double CBNAME(int a, int b) { \
1661 bool found; \
1662 bool blocked = wxPyBeginBlockThreads(); \
1663 double rval; \
1664 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1665 PyObject* ro; \
1666 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1667 if (ro) { \
1668 PyObject* str = PyObject_Str(ro); \
1669 rval = PyFloat_AsDouble(str); \
1670 Py_DECREF(ro); Py_DECREF(str); \
1671 } \
1672 } \
1673 wxPyEndBlockThreads(blocked); \
1674 if (! found) \
1675 rval = PCLASS::CBNAME(a, b); \
1676 return rval; \
1677 } \
1678 double base_##CBNAME(int a, int b) { \
1679 return PCLASS::CBNAME(a, b); \
1680 }
1681
1682
1683
1684 #define PYCALLBACK__(PCLASS, CBNAME) \
1685 void CBNAME() { \
1686 bool found; \
1687 bool blocked = wxPyBeginBlockThreads(); \
1688 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1689 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1690 wxPyEndBlockThreads(blocked); \
1691 if (! found) \
1692 PCLASS::CBNAME(); \
1693 } \
1694 void base_##CBNAME() { \
1695 PCLASS::CBNAME(); \
1696 }
1697
1698
1699
1700
1701 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
1702 bool CBNAME(size_t a, size_t b) { \
1703 bool rval = 0; \
1704 bool found; \
1705 bool blocked = wxPyBeginBlockThreads(); \
1706 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1707 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1708 wxPyEndBlockThreads(blocked); \
1709 if (! found) \
1710 rval = PCLASS::CBNAME(a,b); \
1711 return rval; \
1712 } \
1713 bool base_##CBNAME(size_t a, size_t b) { \
1714 return PCLASS::CBNAME(a,b); \
1715 }
1716
1717
1718
1719 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
1720 bool CBNAME(size_t a) { \
1721 bool rval = 0; \
1722 bool found; \
1723 bool blocked = wxPyBeginBlockThreads(); \
1724 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1725 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1726 wxPyEndBlockThreads(blocked); \
1727 if (! found) \
1728 rval = PCLASS::CBNAME(a); \
1729 return rval; \
1730 } \
1731 bool base_##CBNAME(size_t a) { \
1732 return PCLASS::CBNAME(a); \
1733 }
1734
1735
1736 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
1737 wxString CBNAME(int a) { \
1738 bool found; \
1739 bool blocked = wxPyBeginBlockThreads(); \
1740 wxString rval; \
1741 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1742 PyObject* ro; \
1743 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
1744 if (ro) { \
1745 rval = Py2wxString(ro); \
1746 Py_DECREF(ro); \
1747 } \
1748 } \
1749 wxPyEndBlockThreads(blocked); \
1750 if (! found) \
1751 rval = PCLASS::CBNAME(a); \
1752 return rval; \
1753 } \
1754 wxString base_##CBNAME(int a) { \
1755 return PCLASS::CBNAME(a); \
1756 }
1757
1758
1759 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
1760 void CBNAME(int a, const wxString& c) { \
1761 bool found; \
1762 bool blocked = wxPyBeginBlockThreads(); \
1763 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1764 PyObject* s = wx2PyString(c); \
1765 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
1766 Py_DECREF(s); \
1767 } \
1768 wxPyEndBlockThreads(blocked); \
1769 if (! found) \
1770 PCLASS::CBNAME(a,c); \
1771 } \
1772 void base_##CBNAME(int a, const wxString& c) { \
1773 PCLASS::CBNAME(a,c); \
1774 }
1775
1776
1777
1778
1779 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
1780 bool CBNAME() { \
1781 bool rval = 0; \
1782 bool found; \
1783 bool blocked = wxPyBeginBlockThreads(); \
1784 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1785 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1786 wxPyEndBlockThreads(blocked); \
1787 if (! found) \
1788 rval = PCLASS::CBNAME(); \
1789 return rval; \
1790 } \
1791 bool base_##CBNAME() { \
1792 return PCLASS::CBNAME(); \
1793 }
1794
1795
1796
1797 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
1798 void CBNAME(size_t a, int b) { \
1799 bool found; \
1800 bool blocked = wxPyBeginBlockThreads(); \
1801 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1802 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1803 wxPyEndBlockThreads(blocked); \
1804 if (! found) \
1805 PCLASS::CBNAME(a,b); \
1806 } \
1807 void base_##CBNAME(size_t a, int b) { \
1808 PCLASS::CBNAME(a,b); \
1809 }
1810
1811
1812
1813
1814 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
1815 void CBNAME(int a, int b, long c) { \
1816 bool found; \
1817 bool blocked = wxPyBeginBlockThreads(); \
1818 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1819 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1820 wxPyEndBlockThreads(blocked); \
1821 if (! found) \
1822 PCLASS::CBNAME(a,b,c); \
1823 } \
1824 void base_##CBNAME(int a, int b, long c) { \
1825 PCLASS::CBNAME(a,b,c); \
1826 }
1827
1828
1829
1830
1831 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
1832 void CBNAME(int a, int b, double c) { \
1833 bool found; \
1834 bool blocked = wxPyBeginBlockThreads(); \
1835 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1836 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
1837 wxPyEndBlockThreads(blocked); \
1838 if (! found) \
1839 PCLASS::CBNAME(a,b,c); \
1840 } \
1841 void base_##CBNAME(int a, int b, double c) { \
1842 PCLASS::CBNAME(a,b,c); \
1843 }
1844
1845
1846
1847 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
1848 void CBNAME(int a, int b, bool c) { \
1849 bool found; \
1850 bool blocked = wxPyBeginBlockThreads(); \
1851 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1853 wxPyEndBlockThreads(blocked); \
1854 if (! found) \
1855 PCLASS::CBNAME(a,b,c); \
1856 } \
1857 void base_##CBNAME(int a, int b, bool c) { \
1858 PCLASS::CBNAME(a,b,c); \
1859 }
1860
1861
1862
1863
1864
1865
1866 SWIGINTERN PyObject *
1867 SWIG_FromCharPtr(const char* cptr)
1868 {
1869 if (cptr) {
1870 size_t size = strlen(cptr);
1871 if (size > INT_MAX) {
1872 return SWIG_NewPointerObj((char*)(cptr),
1873 SWIG_TypeQuery("char *"), 0);
1874 } else {
1875 if (size != 0) {
1876 return PyString_FromStringAndSize(cptr, size);
1877 } else {
1878 return PyString_FromString(cptr);
1879 }
1880 }
1881 }
1882 Py_INCREF(Py_None);
1883 return Py_None;
1884 }
1885
1886
1887 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
1888 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
1889 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
1890 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
1891 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
1892 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
1893 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
1894 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
1895 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
1896 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
1897
1898
1899 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1900 #define SWIG_From_int PyInt_FromLong
1901 /*@@*/
1902
1903 static void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
1904 if (!self->GetClientObject())
1905 self->SetClientObject(new wxPyOORClientData(_self));
1906 }
1907
1908 #include <limits.h>
1909
1910
1911 SWIGINTERN int
1912 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1913 const char *errmsg)
1914 {
1915 if (value < min_value) {
1916 if (errmsg) {
1917 PyErr_Format(PyExc_OverflowError,
1918 "value %ld is less than '%s' minimum %ld",
1919 value, errmsg, min_value);
1920 }
1921 return 0;
1922 } else if (value > max_value) {
1923 if (errmsg) {
1924 PyErr_Format(PyExc_OverflowError,
1925 "value %ld is greater than '%s' maximum %ld",
1926 value, errmsg, max_value);
1927 }
1928 return 0;
1929 }
1930 return 1;
1931 }
1932
1933
1934 SWIGINTERN int
1935 SWIG_AsVal_long(PyObject* obj, long* val)
1936 {
1937 if (PyNumber_Check(obj)) {
1938 if (val) *val = PyInt_AsLong(obj);
1939 return 1;
1940 }
1941 else {
1942 SWIG_type_error("number", obj);
1943 }
1944 return 0;
1945 }
1946
1947
1948 #if INT_MAX != LONG_MAX
1949 SWIGINTERN int
1950 SWIG_AsVal_int(PyObject *obj, int *val)
1951 {
1952 const char* errmsg = val ? "int" : (char*)0;
1953 long v;
1954 if (SWIG_AsVal_long(obj, &v)) {
1955 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1956 if (val) *val = (int)(v);
1957 return 1;
1958 } else {
1959 return 0;
1960 }
1961 } else {
1962 PyErr_Clear();
1963 }
1964 if (val) {
1965 SWIG_type_error(errmsg, obj);
1966 }
1967 return 0;
1968 }
1969 #else
1970 SWIGINTERNSHORT int
1971 SWIG_AsVal_int(PyObject *obj, int *val)
1972 {
1973 return SWIG_AsVal_long(obj,(long*)val);
1974 }
1975 #endif
1976
1977
1978 SWIGINTERNSHORT int
1979 SWIG_As_int(PyObject* obj)
1980 {
1981 int v;
1982 if (!SWIG_AsVal_int(obj, &v)) {
1983 /*
1984 this is needed to make valgrind/purify happier.
1985 */
1986 memset((void*)&v, 0, sizeof(int));
1987 }
1988 return v;
1989 }
1990
1991
1992 SWIGINTERN int
1993 SWIG_AsVal_bool(PyObject *obj, bool *val)
1994 {
1995 if (obj == Py_True) {
1996 if (val) *val = true;
1997 return 1;
1998 }
1999 if (obj == Py_False) {
2000 if (val) *val = false;
2001 return 1;
2002 }
2003 int res = 0;
2004 if (SWIG_AsVal_int(obj, &res)) {
2005 if (val) *val = res ? true : false;
2006 return 1;
2007 } else {
2008 PyErr_Clear();
2009 }
2010 if (val) {
2011 SWIG_type_error("bool", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERNSHORT bool
2018 SWIG_As_bool(PyObject* obj)
2019 {
2020 bool v;
2021 if (!SWIG_AsVal_bool(obj, &v)) {
2022 /*
2023 this is needed to make valgrind/purify happier.
2024 */
2025 memset((void*)&v, 0, sizeof(bool));
2026 }
2027 return v;
2028 }
2029
2030
2031 SWIGINTERNSHORT int
2032 SWIG_Check_int(PyObject* obj)
2033 {
2034 return SWIG_AsVal_int(obj, (int*)0);
2035 }
2036
2037
2038 SWIGINTERNSHORT int
2039 SWIG_Check_bool(PyObject* obj)
2040 {
2041 return SWIG_AsVal_bool(obj, (bool*)0);
2042 }
2043
2044
2045 class wxPyGridCellRenderer : public wxGridCellRenderer
2046 {
2047 public:
2048 wxPyGridCellRenderer() : wxGridCellRenderer() {};
2049
2050 // Implement Python callback aware virtual methods
2051 void Draw(wxGrid& grid, wxGridCellAttr& attr,
2052 wxDC& dc, const wxRect& rect,
2053 int row, int col, bool isSelected) {
2054 bool blocked = wxPyBeginBlockThreads();
2055 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
2056 PyObject* go = wxPyMake_wxObject(&grid,false);
2057 PyObject* dco = wxPyMake_wxObject(&dc,false);
2058 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2059 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
2060
2061 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
2062 row, col, isSelected));
2063 Py_DECREF(go);
2064 Py_DECREF(ao);
2065 Py_DECREF(dco);
2066 Py_DECREF(ro);
2067 }
2068 wxPyEndBlockThreads(blocked);
2069 }
2070
2071 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
2072 int row, int col) {
2073 wxSize rval;
2074 bool blocked = wxPyBeginBlockThreads();
2075 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
2076 PyObject* ro;
2077 wxSize* ptr;
2078 PyObject* go = wxPyMake_wxObject(&grid,false);
2079 PyObject* dco = wxPyMake_wxObject(&dc,false);
2080 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2081
2082 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
2083 go, ao, dco,
2084 row, col));
2085 Py_DECREF(go);
2086 Py_DECREF(ao);
2087 Py_DECREF(dco);
2088
2089 if (ro) {
2090 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
2091 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
2092 rval = *ptr;
2093 }
2094 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
2095 PyObject* o1 = PySequence_GetItem(ro, 0);
2096 PyObject* o2 = PySequence_GetItem(ro, 1);
2097 if (PyNumber_Check(o1) && PyNumber_Check(o2))
2098 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
2099 else
2100 PyErr_SetString(PyExc_TypeError, errmsg);
2101 Py_DECREF(o1);
2102 Py_DECREF(o2);
2103 }
2104 else {
2105 PyErr_SetString(PyExc_TypeError, errmsg);
2106 }
2107 Py_DECREF(ro);
2108 }
2109 }
2110 wxPyEndBlockThreads(blocked);
2111 return rval;
2112 }
2113
2114
2115 wxGridCellRenderer *Clone() const {
2116 wxGridCellRenderer* rval = NULL;
2117 bool blocked = wxPyBeginBlockThreads();
2118 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2119 PyObject* ro;
2120 wxGridCellRenderer* ptr;
2121 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2122 if (ro) {
2123 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
2124 rval = ptr;
2125 Py_DECREF(ro);
2126 }
2127 }
2128 wxPyEndBlockThreads(blocked);
2129 return rval;
2130 }
2131
2132 DEC_PYCALLBACK__STRING(SetParameters);
2133
2134 PYPRIVATE;
2135 };
2136
2137 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
2138
2139
2140 static void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
2141 if (!self->GetClientObject())
2142 self->SetClientObject(new wxPyOORClientData(_self));
2143 }
2144
2145 class wxPyGridCellEditor : public wxGridCellEditor
2146 {
2147 public:
2148 wxPyGridCellEditor() : wxGridCellEditor() {}
2149
2150 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
2151 bool blocked = wxPyBeginBlockThreads();
2152 if (wxPyCBH_findCallback(m_myInst, "Create")) {
2153 PyObject* po = wxPyMake_wxObject(parent,false);
2154 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
2155
2156 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
2157 Py_DECREF(po);
2158 Py_DECREF(eo);
2159 }
2160 wxPyEndBlockThreads(blocked);
2161 }
2162
2163
2164 void BeginEdit(int row, int col, wxGrid* grid) {
2165 bool blocked = wxPyBeginBlockThreads();
2166 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
2167 PyObject* go = wxPyMake_wxObject(grid,false);
2168 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2169 Py_DECREF(go);
2170 }
2171 wxPyEndBlockThreads(blocked);
2172 }
2173
2174
2175 bool EndEdit(int row, int col, wxGrid* grid) {
2176 bool rv = false;
2177 bool blocked = wxPyBeginBlockThreads();
2178 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
2179 PyObject* go = wxPyMake_wxObject(grid,false);
2180 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2181 Py_DECREF(go);
2182 }
2183 wxPyEndBlockThreads(blocked);
2184 return rv;
2185 }
2186
2187
2188 wxGridCellEditor* Clone() const {
2189 wxGridCellEditor* rval = NULL;
2190 bool blocked = wxPyBeginBlockThreads();
2191 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2192 PyObject* ro;
2193 wxGridCellEditor* ptr;
2194 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2195 if (ro) {
2196 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
2197 rval = ptr;
2198 Py_DECREF(ro);
2199 }
2200 }
2201 wxPyEndBlockThreads(blocked);
2202 return rval;
2203 }
2204
2205
2206 void Show(bool show, wxGridCellAttr *attr) {
2207 bool found;
2208 bool blocked = wxPyBeginBlockThreads();
2209 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
2210 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2211 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
2212 Py_DECREF(ao);
2213 }
2214 wxPyEndBlockThreads(blocked);
2215 if (! found)
2216 wxGridCellEditor::Show(show, attr);
2217 }
2218 void base_Show(bool show, wxGridCellAttr *attr) {
2219 wxGridCellEditor::Show(show, attr);
2220 }
2221
2222
2223 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2224 bool found;
2225 bool blocked = wxPyBeginBlockThreads();
2226 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
2227 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2228 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
2229
2230 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
2231
2232 Py_DECREF(ro);
2233 Py_DECREF(ao);
2234 }
2235 wxPyEndBlockThreads(blocked);
2236 if (! found)
2237 wxGridCellEditor::PaintBackground(rectCell, attr);
2238 }
2239 void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2240 wxGridCellEditor::PaintBackground(rectCell, attr);
2241 }
2242
2243
2244 DEC_PYCALLBACK___pure(Reset);
2245 DEC_PYCALLBACK__constany(SetSize, wxRect);
2246 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
2247 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
2248 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
2249 DEC_PYCALLBACK__(StartingClick);
2250 DEC_PYCALLBACK__(Destroy);
2251 DEC_PYCALLBACK__STRING(SetParameters);
2252 DEC_PYCALLBACK_STRING__constpure(GetValue);
2253
2254 PYPRIVATE;
2255 };
2256
2257
2258 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
2259 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
2260 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
2261 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
2262 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
2263 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
2264 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
2265 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
2266 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
2267
2268
2269 static void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
2270 if (!self->GetClientObject())
2271 self->SetClientObject(new wxPyOORClientData(_self));
2272 }
2273
2274 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2275 PyObject* o2;
2276 PyObject* o3;
2277
2278 if (!target) {
2279 target = o;
2280 } else if (target == Py_None) {
2281 Py_DECREF(Py_None);
2282 target = o;
2283 } else {
2284 if (!PyTuple_Check(target)) {
2285 o2 = target;
2286 target = PyTuple_New(1);
2287 PyTuple_SetItem(target, 0, o2);
2288 }
2289 o3 = PyTuple_New(1);
2290 PyTuple_SetItem(o3, 0, o);
2291
2292 o2 = target;
2293 target = PySequence_Concat(o2, o3);
2294 Py_DECREF(o2);
2295 Py_DECREF(o3);
2296 }
2297 return target;
2298 }
2299
2300
2301 static void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
2302 if (!self->GetClientObject())
2303 self->SetClientObject(new wxPyOORClientData(_self));
2304 }
2305
2306 SWIGINTERN int
2307 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2308 {
2309 long v = 0;
2310 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2311 SWIG_type_error("unsigned number", obj);
2312 }
2313 else if (val)
2314 *val = (unsigned long)v;
2315 return 1;
2316 }
2317
2318
2319 SWIGINTERNSHORT unsigned long
2320 SWIG_As_unsigned_SS_long(PyObject* obj)
2321 {
2322 unsigned long v;
2323 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2324 /*
2325 this is needed to make valgrind/purify happier.
2326 */
2327 memset((void*)&v, 0, sizeof(unsigned long));
2328 }
2329 return v;
2330 }
2331
2332
2333 SWIGINTERNSHORT int
2334 SWIG_Check_unsigned_SS_long(PyObject* obj)
2335 {
2336 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2337 }
2338
2339
2340 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
2341 {
2342 public:
2343 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
2344
2345 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
2346 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
2347 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
2348 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
2349
2350 PYPRIVATE;
2351 };
2352
2353 static void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
2354 if (!self->GetClientObject())
2355 self->SetClientObject(new wxPyOORClientData(_self));
2356 }
2357
2358 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2359 #define SWIG_From_long PyInt_FromLong
2360 /*@@*/
2361
2362
2363 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2364 #define SWIG_From_double PyFloat_FromDouble
2365 /*@@*/
2366
2367
2368 SWIGINTERNSHORT long
2369 SWIG_As_long(PyObject* obj)
2370 {
2371 long v;
2372 if (!SWIG_AsVal_long(obj, &v)) {
2373 /*
2374 this is needed to make valgrind/purify happier.
2375 */
2376 memset((void*)&v, 0, sizeof(long));
2377 }
2378 return v;
2379 }
2380
2381
2382 SWIGINTERNSHORT int
2383 SWIG_Check_long(PyObject* obj)
2384 {
2385 return SWIG_AsVal_long(obj, (long*)0);
2386 }
2387
2388
2389 SWIGINTERN int
2390 SWIG_AsVal_double(PyObject *obj, double* val)
2391 {
2392 if (PyNumber_Check(obj)) {
2393 if (val) *val = PyFloat_AsDouble(obj);
2394 return 1;
2395 }
2396 else {
2397 SWIG_type_error("number", obj);
2398 }
2399 return 0;
2400 }
2401
2402
2403 SWIGINTERNSHORT double
2404 SWIG_As_double(PyObject* obj)
2405 {
2406 double v;
2407 if (!SWIG_AsVal_double(obj, &v)) {
2408 /*
2409 this is needed to make valgrind/purify happier.
2410 */
2411 memset((void*)&v, 0, sizeof(double));
2412 }
2413 return v;
2414 }
2415
2416
2417 SWIGINTERNSHORT int
2418 SWIG_Check_double(PyObject* obj)
2419 {
2420 return SWIG_AsVal_double(obj, (double*)0);
2421 }
2422
2423
2424 class wxPyGridTableBase : public wxGridTableBase
2425 {
2426 public:
2427 wxPyGridTableBase() : wxGridTableBase() {}
2428
2429 PYCALLBACK_INT__pure(GetNumberRows);
2430 PYCALLBACK_INT__pure(GetNumberCols);
2431 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
2432 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
2433 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
2434 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
2435 PYCALLBACK__(wxGridTableBase, Clear);
2436 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
2437 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
2438 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
2439 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
2440 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
2441 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
2442 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
2443 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
2444 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
2445 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
2446 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
2447 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
2448 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
2449 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
2450 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
2451
2452
2453 wxString GetValue(int row, int col) {
2454 bool blocked = wxPyBeginBlockThreads();
2455 wxString rval;
2456 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2457 PyObject* ro;
2458 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
2459 if (ro) {
2460 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
2461 PyObject* old = ro;
2462 ro = PyObject_Str(ro);
2463 Py_DECREF(old);
2464 }
2465 rval = Py2wxString(ro);
2466 Py_DECREF(ro);
2467 }
2468 }
2469 wxPyEndBlockThreads(blocked);
2470 return rval;
2471 }
2472
2473 void SetValue(int row, int col, const wxString& val) {
2474 bool blocked = wxPyBeginBlockThreads();
2475 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2476 PyObject* s = wx2PyString(val);
2477 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
2478 Py_DECREF(s);
2479 }
2480 wxPyEndBlockThreads(blocked);
2481 }
2482
2483
2484 // Map the Get/Set methods for the standard non-string types to
2485 // the GetValue and SetValue python methods.
2486 long GetValueAsLong( int row, int col ) {
2487 long rval = 0;
2488 bool blocked = wxPyBeginBlockThreads();
2489 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2490 PyObject* ro;
2491 PyObject* num;
2492 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2493 if (ro && PyNumber_Check(ro)) {
2494 num = PyNumber_Int(ro);
2495 if (num) {
2496 rval = PyInt_AsLong(num);
2497 Py_DECREF(num);
2498 }
2499 Py_DECREF(ro);
2500 }
2501 }
2502 wxPyEndBlockThreads(blocked);
2503 return rval;
2504 }
2505
2506 double GetValueAsDouble( int row, int col ) {
2507 double rval = 0.0;
2508 bool blocked = wxPyBeginBlockThreads();
2509 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2510 PyObject* ro;
2511 PyObject* num;
2512 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2513 if (ro && PyNumber_Check(ro)) {
2514 num = PyNumber_Float(ro);
2515 if (num) {
2516 rval = PyFloat_AsDouble(num);
2517 Py_DECREF(num);
2518 }
2519 Py_DECREF(ro);
2520 }
2521 }
2522 wxPyEndBlockThreads(blocked);
2523 return rval;
2524 }
2525
2526 bool GetValueAsBool( int row, int col ) {
2527 return (bool)GetValueAsLong(row, col);
2528 }
2529
2530 void SetValueAsLong( int row, int col, long value ) {
2531 bool blocked = wxPyBeginBlockThreads();
2532 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2533 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
2534 }
2535 wxPyEndBlockThreads(blocked);
2536 }
2537
2538 void SetValueAsDouble( int row, int col, double value ) {
2539 bool blocked = wxPyBeginBlockThreads();
2540 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2541 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
2542 }
2543 wxPyEndBlockThreads(blocked);
2544 }
2545
2546 void SetValueAsBool( int row, int col, bool value ) {
2547 SetValueAsLong( row, col, (long)value );
2548 }
2549
2550
2551 PYPRIVATE;
2552 };
2553
2554 static void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
2555
2556 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
2557
2558 if (source == Py_None) {
2559 **obj = wxGridCellCoords(-1,-1);
2560 return true;
2561 }
2562
2563 // If source is an object instance then it may already be the right type
2564 if (wxPySwigInstance_Check(source)) {
2565 wxGridCellCoords* ptr;
2566 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2567 goto error;
2568 *obj = ptr;
2569 return true;
2570 }
2571 // otherwise a 2-tuple of integers is expected
2572 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2573 PyObject* o1 = PySequence_GetItem(source, 0);
2574 PyObject* o2 = PySequence_GetItem(source, 1);
2575 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2576 Py_DECREF(o1);
2577 Py_DECREF(o2);
2578 goto error;
2579 }
2580 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
2581 Py_DECREF(o1);
2582 Py_DECREF(o2);
2583 return true;
2584 }
2585
2586 error:
2587 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
2588 return false;
2589 }
2590
2591
2592 bool wxGridCellCoords_typecheck(PyObject* source) {
2593 void* ptr;
2594
2595 if (wxPySwigInstance_Check(source) &&
2596 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2597 return true;
2598
2599 PyErr_Clear();
2600 if (PySequence_Check(source) && PySequence_Length(source) == 2)
2601 return true;
2602
2603 return false;
2604 }
2605
2606
2607 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
2608 {
2609 PyObject* list = PyList_New(0);
2610 size_t idx;
2611 for (idx = 0; idx < source.GetCount(); idx += 1) {
2612 wxGridCellCoords& coord = source.Item(idx);
2613 PyObject* tup = PyTuple_New(2);
2614 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
2615 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
2616 PyList_Append(list, tup);
2617 Py_DECREF(tup);
2618 }
2619 return list;
2620 }
2621
2622 static PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
2623 PyObject* tup = PyTuple_New(2);
2624 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
2625 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
2626 return tup;
2627 }
2628
2629 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
2630
2631
2632 static wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
2633 wxGridCellCoords rv;
2634 self->XYToCell(x, y, rv);
2635 return rv;
2636 }
2637 #ifdef __cplusplus
2638 extern "C" {
2639 #endif
2640 static int _wrap_GridNoCellCoords_set(PyObject *) {
2641 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2642 return 1;
2643 }
2644
2645
2646 static PyObject *_wrap_GridNoCellCoords_get(void) {
2647 PyObject *pyobj;
2648
2649 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2650 return pyobj;
2651 }
2652
2653
2654 static int _wrap_GridNoCellRect_set(PyObject *) {
2655 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2656 return 1;
2657 }
2658
2659
2660 static PyObject *_wrap_GridNoCellRect_get(void) {
2661 PyObject *pyobj;
2662
2663 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2664 return pyobj;
2665 }
2666
2667
2668 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2669 PyObject *resultobj;
2670 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2671 PyObject *arg2 = (PyObject *) 0 ;
2672 PyObject * obj0 = 0 ;
2673 PyObject * obj1 = 0 ;
2674 char *kwnames[] = {
2675 (char *) "self",(char *) "_self", NULL
2676 };
2677
2678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2680 if (SWIG_arg_fail(1)) SWIG_fail;
2681 arg2 = obj1;
2682 {
2683 PyThreadState* __tstate = wxPyBeginAllowThreads();
2684 wxGridCellRenderer__setOORInfo(arg1,arg2);
2685
2686 wxPyEndAllowThreads(__tstate);
2687 if (PyErr_Occurred()) SWIG_fail;
2688 }
2689 Py_INCREF(Py_None); resultobj = Py_None;
2690 return resultobj;
2691 fail:
2692 return NULL;
2693 }
2694
2695
2696 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2697 PyObject *resultobj;
2698 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2699 wxString *arg2 = 0 ;
2700 bool temp2 = false ;
2701 PyObject * obj0 = 0 ;
2702 PyObject * obj1 = 0 ;
2703 char *kwnames[] = {
2704 (char *) "self",(char *) "params", NULL
2705 };
2706
2707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2709 if (SWIG_arg_fail(1)) SWIG_fail;
2710 {
2711 arg2 = wxString_in_helper(obj1);
2712 if (arg2 == NULL) SWIG_fail;
2713 temp2 = true;
2714 }
2715 {
2716 PyThreadState* __tstate = wxPyBeginAllowThreads();
2717 (arg1)->SetParameters((wxString const &)*arg2);
2718
2719 wxPyEndAllowThreads(__tstate);
2720 if (PyErr_Occurred()) SWIG_fail;
2721 }
2722 Py_INCREF(Py_None); resultobj = Py_None;
2723 {
2724 if (temp2)
2725 delete arg2;
2726 }
2727 return resultobj;
2728 fail:
2729 {
2730 if (temp2)
2731 delete arg2;
2732 }
2733 return NULL;
2734 }
2735
2736
2737 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2738 PyObject *resultobj;
2739 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2740 PyObject * obj0 = 0 ;
2741 char *kwnames[] = {
2742 (char *) "self", NULL
2743 };
2744
2745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2747 if (SWIG_arg_fail(1)) SWIG_fail;
2748 {
2749 PyThreadState* __tstate = wxPyBeginAllowThreads();
2750 (arg1)->IncRef();
2751
2752 wxPyEndAllowThreads(__tstate);
2753 if (PyErr_Occurred()) SWIG_fail;
2754 }
2755 Py_INCREF(Py_None); resultobj = Py_None;
2756 return resultobj;
2757 fail:
2758 return NULL;
2759 }
2760
2761
2762 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2763 PyObject *resultobj;
2764 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2765 PyObject * obj0 = 0 ;
2766 char *kwnames[] = {
2767 (char *) "self", NULL
2768 };
2769
2770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2772 if (SWIG_arg_fail(1)) SWIG_fail;
2773 {
2774 PyThreadState* __tstate = wxPyBeginAllowThreads();
2775 (arg1)->DecRef();
2776
2777 wxPyEndAllowThreads(__tstate);
2778 if (PyErr_Occurred()) SWIG_fail;
2779 }
2780 Py_INCREF(Py_None); resultobj = Py_None;
2781 return resultobj;
2782 fail:
2783 return NULL;
2784 }
2785
2786
2787 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
2788 PyObject *resultobj;
2789 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2790 wxGrid *arg2 = 0 ;
2791 wxGridCellAttr *arg3 = 0 ;
2792 wxDC *arg4 = 0 ;
2793 wxRect *arg5 = 0 ;
2794 int arg6 ;
2795 int arg7 ;
2796 bool arg8 ;
2797 wxRect temp5 ;
2798 PyObject * obj0 = 0 ;
2799 PyObject * obj1 = 0 ;
2800 PyObject * obj2 = 0 ;
2801 PyObject * obj3 = 0 ;
2802 PyObject * obj4 = 0 ;
2803 PyObject * obj5 = 0 ;
2804 PyObject * obj6 = 0 ;
2805 PyObject * obj7 = 0 ;
2806 char *kwnames[] = {
2807 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
2808 };
2809
2810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2812 if (SWIG_arg_fail(1)) SWIG_fail;
2813 {
2814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2815 if (SWIG_arg_fail(2)) SWIG_fail;
2816 if (arg2 == NULL) {
2817 SWIG_null_ref("wxGrid");
2818 }
2819 if (SWIG_arg_fail(2)) SWIG_fail;
2820 }
2821 {
2822 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2823 if (SWIG_arg_fail(3)) SWIG_fail;
2824 if (arg3 == NULL) {
2825 SWIG_null_ref("wxGridCellAttr");
2826 }
2827 if (SWIG_arg_fail(3)) SWIG_fail;
2828 }
2829 {
2830 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(4)) SWIG_fail;
2832 if (arg4 == NULL) {
2833 SWIG_null_ref("wxDC");
2834 }
2835 if (SWIG_arg_fail(4)) SWIG_fail;
2836 }
2837 {
2838 arg5 = &temp5;
2839 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
2840 }
2841 {
2842 arg6 = (int)(SWIG_As_int(obj5));
2843 if (SWIG_arg_fail(6)) SWIG_fail;
2844 }
2845 {
2846 arg7 = (int)(SWIG_As_int(obj6));
2847 if (SWIG_arg_fail(7)) SWIG_fail;
2848 }
2849 {
2850 arg8 = (bool)(SWIG_As_bool(obj7));
2851 if (SWIG_arg_fail(8)) SWIG_fail;
2852 }
2853 {
2854 PyThreadState* __tstate = wxPyBeginAllowThreads();
2855 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
2856
2857 wxPyEndAllowThreads(__tstate);
2858 if (PyErr_Occurred()) SWIG_fail;
2859 }
2860 Py_INCREF(Py_None); resultobj = Py_None;
2861 return resultobj;
2862 fail:
2863 return NULL;
2864 }
2865
2866
2867 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
2868 PyObject *resultobj;
2869 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2870 wxGrid *arg2 = 0 ;
2871 wxGridCellAttr *arg3 = 0 ;
2872 wxDC *arg4 = 0 ;
2873 int arg5 ;
2874 int arg6 ;
2875 wxSize result;
2876 PyObject * obj0 = 0 ;
2877 PyObject * obj1 = 0 ;
2878 PyObject * obj2 = 0 ;
2879 PyObject * obj3 = 0 ;
2880 PyObject * obj4 = 0 ;
2881 PyObject * obj5 = 0 ;
2882 char *kwnames[] = {
2883 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
2884 };
2885
2886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2888 if (SWIG_arg_fail(1)) SWIG_fail;
2889 {
2890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2891 if (SWIG_arg_fail(2)) SWIG_fail;
2892 if (arg2 == NULL) {
2893 SWIG_null_ref("wxGrid");
2894 }
2895 if (SWIG_arg_fail(2)) SWIG_fail;
2896 }
2897 {
2898 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2899 if (SWIG_arg_fail(3)) SWIG_fail;
2900 if (arg3 == NULL) {
2901 SWIG_null_ref("wxGridCellAttr");
2902 }
2903 if (SWIG_arg_fail(3)) SWIG_fail;
2904 }
2905 {
2906 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2907 if (SWIG_arg_fail(4)) SWIG_fail;
2908 if (arg4 == NULL) {
2909 SWIG_null_ref("wxDC");
2910 }
2911 if (SWIG_arg_fail(4)) SWIG_fail;
2912 }
2913 {
2914 arg5 = (int)(SWIG_As_int(obj4));
2915 if (SWIG_arg_fail(5)) SWIG_fail;
2916 }
2917 {
2918 arg6 = (int)(SWIG_As_int(obj5));
2919 if (SWIG_arg_fail(6)) SWIG_fail;
2920 }
2921 {
2922 PyThreadState* __tstate = wxPyBeginAllowThreads();
2923 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
2924
2925 wxPyEndAllowThreads(__tstate);
2926 if (PyErr_Occurred()) SWIG_fail;
2927 }
2928 {
2929 wxSize * resultptr;
2930 resultptr = new wxSize((wxSize &)(result));
2931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2932 }
2933 return resultobj;
2934 fail:
2935 return NULL;
2936 }
2937
2938
2939 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
2940 PyObject *resultobj;
2941 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2942 wxGridCellRenderer *result;
2943 PyObject * obj0 = 0 ;
2944 char *kwnames[] = {
2945 (char *) "self", NULL
2946 };
2947
2948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
2949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2950 if (SWIG_arg_fail(1)) SWIG_fail;
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
2960 }
2961 return resultobj;
2962 fail:
2963 return NULL;
2964 }
2965
2966
2967 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
2968 PyObject *obj;
2969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2970 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
2971 Py_INCREF(obj);
2972 return Py_BuildValue((char *)"");
2973 }
2974 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
2975 PyObject *resultobj;
2976 wxPyGridCellRenderer *result;
2977 char *kwnames[] = {
2978 NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
2982 {
2983 PyThreadState* __tstate = wxPyBeginAllowThreads();
2984 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
2985
2986 wxPyEndAllowThreads(__tstate);
2987 if (PyErr_Occurred()) SWIG_fail;
2988 }
2989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
2990 return resultobj;
2991 fail:
2992 return NULL;
2993 }
2994
2995
2996 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2997 PyObject *resultobj;
2998 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
2999 PyObject *arg2 = (PyObject *) 0 ;
3000 PyObject *arg3 = (PyObject *) 0 ;
3001 PyObject * obj0 = 0 ;
3002 PyObject * obj1 = 0 ;
3003 PyObject * obj2 = 0 ;
3004 char *kwnames[] = {
3005 (char *) "self",(char *) "self",(char *) "_class", NULL
3006 };
3007
3008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3010 if (SWIG_arg_fail(1)) SWIG_fail;
3011 arg2 = obj1;
3012 arg3 = obj2;
3013 {
3014 PyThreadState* __tstate = wxPyBeginAllowThreads();
3015 (arg1)->_setCallbackInfo(arg2,arg3);
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 Py_INCREF(Py_None); resultobj = Py_None;
3021 return resultobj;
3022 fail:
3023 return NULL;
3024 }
3025
3026
3027 static PyObject *_wrap_PyGridCellRenderer_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3028 PyObject *resultobj;
3029 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3030 wxString *arg2 = 0 ;
3031 bool temp2 = false ;
3032 PyObject * obj0 = 0 ;
3033 PyObject * obj1 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "self",(char *) "params", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3040 if (SWIG_arg_fail(1)) SWIG_fail;
3041 {
3042 arg2 = wxString_in_helper(obj1);
3043 if (arg2 == NULL) SWIG_fail;
3044 temp2 = true;
3045 }
3046 {
3047 PyThreadState* __tstate = wxPyBeginAllowThreads();
3048 (arg1)->base_SetParameters((wxString const &)*arg2);
3049
3050 wxPyEndAllowThreads(__tstate);
3051 if (PyErr_Occurred()) SWIG_fail;
3052 }
3053 Py_INCREF(Py_None); resultobj = Py_None;
3054 {
3055 if (temp2)
3056 delete arg2;
3057 }
3058 return resultobj;
3059 fail:
3060 {
3061 if (temp2)
3062 delete arg2;
3063 }
3064 return NULL;
3065 }
3066
3067
3068 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3069 PyObject *obj;
3070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3071 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3072 Py_INCREF(obj);
3073 return Py_BuildValue((char *)"");
3074 }
3075 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3076 PyObject *resultobj;
3077 wxGridCellStringRenderer *result;
3078 char *kwnames[] = {
3079 NULL
3080 };
3081
3082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3083 {
3084 PyThreadState* __tstate = wxPyBeginAllowThreads();
3085 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3086
3087 wxPyEndAllowThreads(__tstate);
3088 if (PyErr_Occurred()) SWIG_fail;
3089 }
3090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3091 return resultobj;
3092 fail:
3093 return NULL;
3094 }
3095
3096
3097 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3098 PyObject *obj;
3099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3100 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3101 Py_INCREF(obj);
3102 return Py_BuildValue((char *)"");
3103 }
3104 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3105 PyObject *resultobj;
3106 wxGridCellNumberRenderer *result;
3107 char *kwnames[] = {
3108 NULL
3109 };
3110
3111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3112 {
3113 PyThreadState* __tstate = wxPyBeginAllowThreads();
3114 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3115
3116 wxPyEndAllowThreads(__tstate);
3117 if (PyErr_Occurred()) SWIG_fail;
3118 }
3119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3120 return resultobj;
3121 fail:
3122 return NULL;
3123 }
3124
3125
3126 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3127 PyObject *obj;
3128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3129 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3130 Py_INCREF(obj);
3131 return Py_BuildValue((char *)"");
3132 }
3133 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3134 PyObject *resultobj;
3135 int arg1 = (int) -1 ;
3136 int arg2 = (int) -1 ;
3137 wxGridCellFloatRenderer *result;
3138 PyObject * obj0 = 0 ;
3139 PyObject * obj1 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "width",(char *) "precision", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3145 if (obj0) {
3146 {
3147 arg1 = (int)(SWIG_As_int(obj0));
3148 if (SWIG_arg_fail(1)) SWIG_fail;
3149 }
3150 }
3151 if (obj1) {
3152 {
3153 arg2 = (int)(SWIG_As_int(obj1));
3154 if (SWIG_arg_fail(2)) SWIG_fail;
3155 }
3156 }
3157 {
3158 PyThreadState* __tstate = wxPyBeginAllowThreads();
3159 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3160
3161 wxPyEndAllowThreads(__tstate);
3162 if (PyErr_Occurred()) SWIG_fail;
3163 }
3164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3165 return resultobj;
3166 fail:
3167 return NULL;
3168 }
3169
3170
3171 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3172 PyObject *resultobj;
3173 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3174 int result;
3175 PyObject * obj0 = 0 ;
3176 char *kwnames[] = {
3177 (char *) "self", NULL
3178 };
3179
3180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3182 if (SWIG_arg_fail(1)) SWIG_fail;
3183 {
3184 PyThreadState* __tstate = wxPyBeginAllowThreads();
3185 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3186
3187 wxPyEndAllowThreads(__tstate);
3188 if (PyErr_Occurred()) SWIG_fail;
3189 }
3190 {
3191 resultobj = SWIG_From_int((int)(result));
3192 }
3193 return resultobj;
3194 fail:
3195 return NULL;
3196 }
3197
3198
3199 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3200 PyObject *resultobj;
3201 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3202 int arg2 ;
3203 PyObject * obj0 = 0 ;
3204 PyObject * obj1 = 0 ;
3205 char *kwnames[] = {
3206 (char *) "self",(char *) "width", NULL
3207 };
3208
3209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3211 if (SWIG_arg_fail(1)) SWIG_fail;
3212 {
3213 arg2 = (int)(SWIG_As_int(obj1));
3214 if (SWIG_arg_fail(2)) SWIG_fail;
3215 }
3216 {
3217 PyThreadState* __tstate = wxPyBeginAllowThreads();
3218 (arg1)->SetWidth(arg2);
3219
3220 wxPyEndAllowThreads(__tstate);
3221 if (PyErr_Occurred()) SWIG_fail;
3222 }
3223 Py_INCREF(Py_None); resultobj = Py_None;
3224 return resultobj;
3225 fail:
3226 return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj;
3232 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3233 int result;
3234 PyObject * obj0 = 0 ;
3235 char *kwnames[] = {
3236 (char *) "self", NULL
3237 };
3238
3239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3241 if (SWIG_arg_fail(1)) SWIG_fail;
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 {
3250 resultobj = SWIG_From_int((int)(result));
3251 }
3252 return resultobj;
3253 fail:
3254 return NULL;
3255 }
3256
3257
3258 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3259 PyObject *resultobj;
3260 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3261 int arg2 ;
3262 PyObject * obj0 = 0 ;
3263 PyObject * obj1 = 0 ;
3264 char *kwnames[] = {
3265 (char *) "self",(char *) "precision", NULL
3266 };
3267
3268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3270 if (SWIG_arg_fail(1)) SWIG_fail;
3271 {
3272 arg2 = (int)(SWIG_As_int(obj1));
3273 if (SWIG_arg_fail(2)) SWIG_fail;
3274 }
3275 {
3276 PyThreadState* __tstate = wxPyBeginAllowThreads();
3277 (arg1)->SetPrecision(arg2);
3278
3279 wxPyEndAllowThreads(__tstate);
3280 if (PyErr_Occurred()) SWIG_fail;
3281 }
3282 Py_INCREF(Py_None); resultobj = Py_None;
3283 return resultobj;
3284 fail:
3285 return NULL;
3286 }
3287
3288
3289 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3290 PyObject *obj;
3291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3292 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3293 Py_INCREF(obj);
3294 return Py_BuildValue((char *)"");
3295 }
3296 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3297 PyObject *resultobj;
3298 wxGridCellBoolRenderer *result;
3299 char *kwnames[] = {
3300 NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3304 {
3305 PyThreadState* __tstate = wxPyBeginAllowThreads();
3306 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3307
3308 wxPyEndAllowThreads(__tstate);
3309 if (PyErr_Occurred()) SWIG_fail;
3310 }
3311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3312 return resultobj;
3313 fail:
3314 return NULL;
3315 }
3316
3317
3318 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3319 PyObject *obj;
3320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3321 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3322 Py_INCREF(obj);
3323 return Py_BuildValue((char *)"");
3324 }
3325 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
3328 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
3329 wxGridCellDateTimeRenderer *result;
3330 PyObject * obj0 = 0 ;
3331 PyObject * obj1 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "outformat",(char *) "informat", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3337 if (obj0) {
3338 {
3339 wxString* sptr = wxString_in_helper(obj0);
3340 if (sptr == NULL) SWIG_fail;
3341 arg1 = *sptr;
3342 delete sptr;
3343 }
3344 }
3345 if (obj1) {
3346 {
3347 wxString* sptr = wxString_in_helper(obj1);
3348 if (sptr == NULL) SWIG_fail;
3349 arg2 = *sptr;
3350 delete sptr;
3351 }
3352 }
3353 {
3354 PyThreadState* __tstate = wxPyBeginAllowThreads();
3355 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3356
3357 wxPyEndAllowThreads(__tstate);
3358 if (PyErr_Occurred()) SWIG_fail;
3359 }
3360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3361 return resultobj;
3362 fail:
3363 return NULL;
3364 }
3365
3366
3367 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3368 PyObject *obj;
3369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3370 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3371 Py_INCREF(obj);
3372 return Py_BuildValue((char *)"");
3373 }
3374 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3375 PyObject *resultobj;
3376 wxString const &arg1_defvalue = wxPyEmptyString ;
3377 wxString *arg1 = (wxString *) &arg1_defvalue ;
3378 wxGridCellEnumRenderer *result;
3379 bool temp1 = false ;
3380 PyObject * obj0 = 0 ;
3381 char *kwnames[] = {
3382 (char *) "choices", NULL
3383 };
3384
3385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3386 if (obj0) {
3387 {
3388 arg1 = wxString_in_helper(obj0);
3389 if (arg1 == NULL) SWIG_fail;
3390 temp1 = true;
3391 }
3392 }
3393 {
3394 PyThreadState* __tstate = wxPyBeginAllowThreads();
3395 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3396
3397 wxPyEndAllowThreads(__tstate);
3398 if (PyErr_Occurred()) SWIG_fail;
3399 }
3400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3401 {
3402 if (temp1)
3403 delete arg1;
3404 }
3405 return resultobj;
3406 fail:
3407 {
3408 if (temp1)
3409 delete arg1;
3410 }
3411 return NULL;
3412 }
3413
3414
3415 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3416 PyObject *obj;
3417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3418 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3419 Py_INCREF(obj);
3420 return Py_BuildValue((char *)"");
3421 }
3422 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3423 PyObject *resultobj;
3424 wxGridCellAutoWrapStringRenderer *result;
3425 char *kwnames[] = {
3426 NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3430 {
3431 PyThreadState* __tstate = wxPyBeginAllowThreads();
3432 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3433
3434 wxPyEndAllowThreads(__tstate);
3435 if (PyErr_Occurred()) SWIG_fail;
3436 }
3437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3438 return resultobj;
3439 fail:
3440 return NULL;
3441 }
3442
3443
3444 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3445 PyObject *obj;
3446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3447 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3448 Py_INCREF(obj);
3449 return Py_BuildValue((char *)"");
3450 }
3451 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3454 PyObject *arg2 = (PyObject *) 0 ;
3455 PyObject * obj0 = 0 ;
3456 PyObject * obj1 = 0 ;
3457 char *kwnames[] = {
3458 (char *) "self",(char *) "_self", NULL
3459 };
3460
3461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3463 if (SWIG_arg_fail(1)) SWIG_fail;
3464 arg2 = obj1;
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 wxGridCellEditor__setOORInfo(arg1,arg2);
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 Py_INCREF(Py_None); resultobj = Py_None;
3473 return resultobj;
3474 fail:
3475 return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3480 PyObject *resultobj;
3481 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3482 bool result;
3483 PyObject * obj0 = 0 ;
3484 char *kwnames[] = {
3485 (char *) "self", NULL
3486 };
3487
3488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3490 if (SWIG_arg_fail(1)) SWIG_fail;
3491 {
3492 PyThreadState* __tstate = wxPyBeginAllowThreads();
3493 result = (bool)(arg1)->IsCreated();
3494
3495 wxPyEndAllowThreads(__tstate);
3496 if (PyErr_Occurred()) SWIG_fail;
3497 }
3498 {
3499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3500 }
3501 return resultobj;
3502 fail:
3503 return NULL;
3504 }
3505
3506
3507 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3508 PyObject *resultobj;
3509 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3510 wxControl *result;
3511 PyObject * obj0 = 0 ;
3512 char *kwnames[] = {
3513 (char *) "self", NULL
3514 };
3515
3516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3518 if (SWIG_arg_fail(1)) SWIG_fail;
3519 {
3520 PyThreadState* __tstate = wxPyBeginAllowThreads();
3521 result = (wxControl *)(arg1)->GetControl();
3522
3523 wxPyEndAllowThreads(__tstate);
3524 if (PyErr_Occurred()) SWIG_fail;
3525 }
3526 {
3527 resultobj = wxPyMake_wxObject(result, 0);
3528 }
3529 return resultobj;
3530 fail:
3531 return NULL;
3532 }
3533
3534
3535 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3536 PyObject *resultobj;
3537 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3538 wxControl *arg2 = (wxControl *) 0 ;
3539 PyObject * obj0 = 0 ;
3540 PyObject * obj1 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "self",(char *) "control", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3549 if (SWIG_arg_fail(2)) SWIG_fail;
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 (arg1)->SetControl(arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 Py_INCREF(Py_None); resultobj = Py_None;
3558 return resultobj;
3559 fail:
3560 return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3565 PyObject *resultobj;
3566 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3567 wxGridCellAttr *result;
3568 PyObject * obj0 = 0 ;
3569 char *kwnames[] = {
3570 (char *) "self", NULL
3571 };
3572
3573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3575 if (SWIG_arg_fail(1)) SWIG_fail;
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 resultobj = wxPyMake_wxGridCellAttr(result, 0);
3585 }
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3595 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3596 PyObject * obj0 = 0 ;
3597 PyObject * obj1 = 0 ;
3598 char *kwnames[] = {
3599 (char *) "self",(char *) "attr", NULL
3600 };
3601
3602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3604 if (SWIG_arg_fail(1)) SWIG_fail;
3605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3606 if (SWIG_arg_fail(2)) SWIG_fail;
3607 {
3608 PyThreadState* __tstate = wxPyBeginAllowThreads();
3609 (arg1)->SetCellAttr(arg2);
3610
3611 wxPyEndAllowThreads(__tstate);
3612 if (PyErr_Occurred()) SWIG_fail;
3613 }
3614 Py_INCREF(Py_None); resultobj = Py_None;
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3622 PyObject *resultobj;
3623 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3624 wxString *arg2 = 0 ;
3625 bool temp2 = false ;
3626 PyObject * obj0 = 0 ;
3627 PyObject * obj1 = 0 ;
3628 char *kwnames[] = {
3629 (char *) "self",(char *) "params", NULL
3630 };
3631
3632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3634 if (SWIG_arg_fail(1)) SWIG_fail;
3635 {
3636 arg2 = wxString_in_helper(obj1);
3637 if (arg2 == NULL) SWIG_fail;
3638 temp2 = true;
3639 }
3640 {
3641 PyThreadState* __tstate = wxPyBeginAllowThreads();
3642 (arg1)->SetParameters((wxString const &)*arg2);
3643
3644 wxPyEndAllowThreads(__tstate);
3645 if (PyErr_Occurred()) SWIG_fail;
3646 }
3647 Py_INCREF(Py_None); resultobj = Py_None;
3648 {
3649 if (temp2)
3650 delete arg2;
3651 }
3652 return resultobj;
3653 fail:
3654 {
3655 if (temp2)
3656 delete arg2;
3657 }
3658 return NULL;
3659 }
3660
3661
3662 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3665 PyObject * obj0 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "self", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3672 if (SWIG_arg_fail(1)) SWIG_fail;
3673 {
3674 PyThreadState* __tstate = wxPyBeginAllowThreads();
3675 (arg1)->IncRef();
3676
3677 wxPyEndAllowThreads(__tstate);
3678 if (PyErr_Occurred()) SWIG_fail;
3679 }
3680 Py_INCREF(Py_None); resultobj = Py_None;
3681 return resultobj;
3682 fail:
3683 return NULL;
3684 }
3685
3686
3687 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3688 PyObject *resultobj;
3689 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3690 PyObject * obj0 = 0 ;
3691 char *kwnames[] = {
3692 (char *) "self", NULL
3693 };
3694
3695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3697 if (SWIG_arg_fail(1)) SWIG_fail;
3698 {
3699 PyThreadState* __tstate = wxPyBeginAllowThreads();
3700 (arg1)->DecRef();
3701
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 Py_INCREF(Py_None); resultobj = Py_None;
3706 return resultobj;
3707 fail:
3708 return NULL;
3709 }
3710
3711
3712 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3713 PyObject *resultobj;
3714 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3715 wxWindow *arg2 = (wxWindow *) 0 ;
3716 int arg3 ;
3717 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3718 PyObject * obj0 = 0 ;
3719 PyObject * obj1 = 0 ;
3720 PyObject * obj2 = 0 ;
3721 PyObject * obj3 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3730 if (SWIG_arg_fail(2)) SWIG_fail;
3731 {
3732 arg3 = (int)(SWIG_As_int(obj2));
3733 if (SWIG_arg_fail(3)) SWIG_fail;
3734 }
3735 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3736 if (SWIG_arg_fail(4)) SWIG_fail;
3737 {
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 (arg1)->Create(arg2,arg3,arg4);
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3754 int arg2 ;
3755 int arg3 ;
3756 wxGrid *arg4 = (wxGrid *) 0 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 PyObject * obj2 = 0 ;
3760 PyObject * obj3 = 0 ;
3761 char *kwnames[] = {
3762 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 {
3769 arg2 = (int)(SWIG_As_int(obj1));
3770 if (SWIG_arg_fail(2)) SWIG_fail;
3771 }
3772 {
3773 arg3 = (int)(SWIG_As_int(obj2));
3774 if (SWIG_arg_fail(3)) SWIG_fail;
3775 }
3776 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3777 if (SWIG_arg_fail(4)) SWIG_fail;
3778 {
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 (arg1)->BeginEdit(arg2,arg3,arg4);
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 Py_INCREF(Py_None); resultobj = Py_None;
3786 return resultobj;
3787 fail:
3788 return NULL;
3789 }
3790
3791
3792 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3793 PyObject *resultobj;
3794 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3795 int arg2 ;
3796 int arg3 ;
3797 wxGrid *arg4 = (wxGrid *) 0 ;
3798 bool result;
3799 PyObject * obj0 = 0 ;
3800 PyObject * obj1 = 0 ;
3801 PyObject * obj2 = 0 ;
3802 PyObject * obj3 = 0 ;
3803 char *kwnames[] = {
3804 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(1)) SWIG_fail;
3810 {
3811 arg2 = (int)(SWIG_As_int(obj1));
3812 if (SWIG_arg_fail(2)) SWIG_fail;
3813 }
3814 {
3815 arg3 = (int)(SWIG_As_int(obj2));
3816 if (SWIG_arg_fail(3)) SWIG_fail;
3817 }
3818 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3819 if (SWIG_arg_fail(4)) SWIG_fail;
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj;
3838 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3839 PyObject * obj0 = 0 ;
3840 char *kwnames[] = {
3841 (char *) "self", NULL
3842 };
3843
3844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
3845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3846 if (SWIG_arg_fail(1)) SWIG_fail;
3847 {
3848 PyThreadState* __tstate = wxPyBeginAllowThreads();
3849 (arg1)->Reset();
3850
3851 wxPyEndAllowThreads(__tstate);
3852 if (PyErr_Occurred()) SWIG_fail;
3853 }
3854 Py_INCREF(Py_None); resultobj = Py_None;
3855 return resultobj;
3856 fail:
3857 return NULL;
3858 }
3859
3860
3861 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3862 PyObject *resultobj;
3863 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3864 wxGridCellEditor *result;
3865 PyObject * obj0 = 0 ;
3866 char *kwnames[] = {
3867 (char *) "self", NULL
3868 };
3869
3870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
3871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3872 if (SWIG_arg_fail(1)) SWIG_fail;
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 {
3881 resultobj = wxPyMake_wxGridCellEditor(result, 0);
3882 }
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
3890 PyObject *resultobj;
3891 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3892 wxRect *arg2 = 0 ;
3893 wxRect temp2 ;
3894 PyObject * obj0 = 0 ;
3895 PyObject * obj1 = 0 ;
3896 char *kwnames[] = {
3897 (char *) "self",(char *) "rect", NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
3901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3902 if (SWIG_arg_fail(1)) SWIG_fail;
3903 {
3904 arg2 = &temp2;
3905 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3906 }
3907 {
3908 PyThreadState* __tstate = wxPyBeginAllowThreads();
3909 (arg1)->SetSize((wxRect const &)*arg2);
3910
3911 wxPyEndAllowThreads(__tstate);
3912 if (PyErr_Occurred()) SWIG_fail;
3913 }
3914 Py_INCREF(Py_None); resultobj = Py_None;
3915 return resultobj;
3916 fail:
3917 return NULL;
3918 }
3919
3920
3921 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
3922 PyObject *resultobj;
3923 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3924 bool arg2 ;
3925 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
3926 PyObject * obj0 = 0 ;
3927 PyObject * obj1 = 0 ;
3928 PyObject * obj2 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "self",(char *) "show",(char *) "attr", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
3934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 {
3937 arg2 = (bool)(SWIG_As_bool(obj1));
3938 if (SWIG_arg_fail(2)) SWIG_fail;
3939 }
3940 if (obj2) {
3941 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3942 if (SWIG_arg_fail(3)) SWIG_fail;
3943 }
3944 {
3945 PyThreadState* __tstate = wxPyBeginAllowThreads();
3946 (arg1)->Show(arg2,arg3);
3947
3948 wxPyEndAllowThreads(__tstate);
3949 if (PyErr_Occurred()) SWIG_fail;
3950 }
3951 Py_INCREF(Py_None); resultobj = Py_None;
3952 return resultobj;
3953 fail:
3954 return NULL;
3955 }
3956
3957
3958 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
3959 PyObject *resultobj;
3960 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3961 wxRect *arg2 = 0 ;
3962 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
3963 wxRect temp2 ;
3964 PyObject * obj0 = 0 ;
3965 PyObject * obj1 = 0 ;
3966 PyObject * obj2 = 0 ;
3967 char *kwnames[] = {
3968 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
3972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3973 if (SWIG_arg_fail(1)) SWIG_fail;
3974 {
3975 arg2 = &temp2;
3976 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3977 }
3978 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3979 if (SWIG_arg_fail(3)) SWIG_fail;
3980 {
3981 PyThreadState* __tstate = wxPyBeginAllowThreads();
3982 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
3983
3984 wxPyEndAllowThreads(__tstate);
3985 if (PyErr_Occurred()) SWIG_fail;
3986 }
3987 Py_INCREF(Py_None); resultobj = Py_None;
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3997 wxKeyEvent *arg2 = 0 ;
3998 bool result;
3999 PyObject * obj0 = 0 ;
4000 PyObject * obj1 = 0 ;
4001 char *kwnames[] = {
4002 (char *) "self",(char *) "event", NULL
4003 };
4004
4005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4007 if (SWIG_arg_fail(1)) SWIG_fail;
4008 {
4009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4010 if (SWIG_arg_fail(2)) SWIG_fail;
4011 if (arg2 == NULL) {
4012 SWIG_null_ref("wxKeyEvent");
4013 }
4014 if (SWIG_arg_fail(2)) SWIG_fail;
4015 }
4016 {
4017 PyThreadState* __tstate = wxPyBeginAllowThreads();
4018 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4019
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 {
4024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4025 }
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4035 wxKeyEvent *arg2 = 0 ;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "self",(char *) "event", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4044 if (SWIG_arg_fail(1)) SWIG_fail;
4045 {
4046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4047 if (SWIG_arg_fail(2)) SWIG_fail;
4048 if (arg2 == NULL) {
4049 SWIG_null_ref("wxKeyEvent");
4050 }
4051 if (SWIG_arg_fail(2)) SWIG_fail;
4052 }
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 (arg1)->StartingKey(*arg2);
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4070 PyObject * obj0 = 0 ;
4071 char *kwnames[] = {
4072 (char *) "self", NULL
4073 };
4074
4075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4077 if (SWIG_arg_fail(1)) SWIG_fail;
4078 {
4079 PyThreadState* __tstate = wxPyBeginAllowThreads();
4080 (arg1)->StartingClick();
4081
4082 wxPyEndAllowThreads(__tstate);
4083 if (PyErr_Occurred()) SWIG_fail;
4084 }
4085 Py_INCREF(Py_None); resultobj = Py_None;
4086 return resultobj;
4087 fail:
4088 return NULL;
4089 }
4090
4091
4092 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4093 PyObject *resultobj;
4094 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4095 wxKeyEvent *arg2 = 0 ;
4096 PyObject * obj0 = 0 ;
4097 PyObject * obj1 = 0 ;
4098 char *kwnames[] = {
4099 (char *) "self",(char *) "event", NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 {
4106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4107 if (SWIG_arg_fail(2)) SWIG_fail;
4108 if (arg2 == NULL) {
4109 SWIG_null_ref("wxKeyEvent");
4110 }
4111 if (SWIG_arg_fail(2)) SWIG_fail;
4112 }
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 (arg1)->HandleReturn(*arg2);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 Py_INCREF(Py_None); resultobj = Py_None;
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4130 PyObject * obj0 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "self", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 {
4139 PyThreadState* __tstate = wxPyBeginAllowThreads();
4140 (arg1)->Destroy();
4141
4142 wxPyEndAllowThreads(__tstate);
4143 if (PyErr_Occurred()) SWIG_fail;
4144 }
4145 Py_INCREF(Py_None); resultobj = Py_None;
4146 return resultobj;
4147 fail:
4148 return NULL;
4149 }
4150
4151
4152 static PyObject * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4153 PyObject *obj;
4154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4155 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4156 Py_INCREF(obj);
4157 return Py_BuildValue((char *)"");
4158 }
4159 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4160 PyObject *resultobj;
4161 wxPyGridCellEditor *result;
4162 char *kwnames[] = {
4163 NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4175 return resultobj;
4176 fail:
4177 return NULL;
4178 }
4179
4180
4181 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4182 PyObject *resultobj;
4183 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4184 PyObject *arg2 = (PyObject *) 0 ;
4185 PyObject *arg3 = (PyObject *) 0 ;
4186 PyObject * obj0 = 0 ;
4187 PyObject * obj1 = 0 ;
4188 PyObject * obj2 = 0 ;
4189 char *kwnames[] = {
4190 (char *) "self",(char *) "self",(char *) "_class", NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4195 if (SWIG_arg_fail(1)) SWIG_fail;
4196 arg2 = obj1;
4197 arg3 = obj2;
4198 {
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 (arg1)->_setCallbackInfo(arg2,arg3);
4201
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 Py_INCREF(Py_None); resultobj = Py_None;
4206 return resultobj;
4207 fail:
4208 return NULL;
4209 }
4210
4211
4212 static PyObject *_wrap_PyGridCellEditor_base_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj;
4214 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4215 wxRect *arg2 = 0 ;
4216 wxRect temp2 ;
4217 PyObject * obj0 = 0 ;
4218 PyObject * obj1 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "self",(char *) "rect", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetSize",kwnames,&obj0,&obj1)) goto fail;
4224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4225 if (SWIG_arg_fail(1)) SWIG_fail;
4226 {
4227 arg2 = &temp2;
4228 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4229 }
4230 {
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 (arg1)->base_SetSize((wxRect const &)*arg2);
4233
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 Py_INCREF(Py_None); resultobj = Py_None;
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_PyGridCellEditor_base_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4247 bool arg2 ;
4248 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4249 PyObject * obj0 = 0 ;
4250 PyObject * obj1 = 0 ;
4251 PyObject * obj2 = 0 ;
4252 char *kwnames[] = {
4253 (char *) "self",(char *) "show",(char *) "attr", NULL
4254 };
4255
4256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_base_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4258 if (SWIG_arg_fail(1)) SWIG_fail;
4259 {
4260 arg2 = (bool)(SWIG_As_bool(obj1));
4261 if (SWIG_arg_fail(2)) SWIG_fail;
4262 }
4263 if (obj2) {
4264 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4265 if (SWIG_arg_fail(3)) SWIG_fail;
4266 }
4267 {
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 (arg1)->base_Show(arg2,arg3);
4270
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 Py_INCREF(Py_None); resultobj = Py_None;
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 static PyObject *_wrap_PyGridCellEditor_base_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4284 wxRect *arg2 = 0 ;
4285 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4286 wxRect temp2 ;
4287 PyObject * obj0 = 0 ;
4288 PyObject * obj1 = 0 ;
4289 PyObject * obj2 = 0 ;
4290 char *kwnames[] = {
4291 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4292 };
4293
4294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_base_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4296 if (SWIG_arg_fail(1)) SWIG_fail;
4297 {
4298 arg2 = &temp2;
4299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4300 }
4301 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4302 if (SWIG_arg_fail(3)) SWIG_fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 (arg1)->base_PaintBackground((wxRect const &)*arg2,arg3);
4306
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 Py_INCREF(Py_None); resultobj = Py_None;
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 static PyObject *_wrap_PyGridCellEditor_base_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj;
4319 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4320 wxKeyEvent *arg2 = 0 ;
4321 bool result;
4322 PyObject * obj0 = 0 ;
4323 PyObject * obj1 = 0 ;
4324 char *kwnames[] = {
4325 (char *) "self",(char *) "event", NULL
4326 };
4327
4328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4330 if (SWIG_arg_fail(1)) SWIG_fail;
4331 {
4332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4333 if (SWIG_arg_fail(2)) SWIG_fail;
4334 if (arg2 == NULL) {
4335 SWIG_null_ref("wxKeyEvent");
4336 }
4337 if (SWIG_arg_fail(2)) SWIG_fail;
4338 }
4339 {
4340 PyThreadState* __tstate = wxPyBeginAllowThreads();
4341 result = (bool)(arg1)->base_IsAcceptedKey(*arg2);
4342
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 {
4347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4348 }
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_PyGridCellEditor_base_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj;
4357 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4358 wxKeyEvent *arg2 = 0 ;
4359 PyObject * obj0 = 0 ;
4360 PyObject * obj1 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "self",(char *) "event", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4367 if (SWIG_arg_fail(1)) SWIG_fail;
4368 {
4369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4370 if (SWIG_arg_fail(2)) SWIG_fail;
4371 if (arg2 == NULL) {
4372 SWIG_null_ref("wxKeyEvent");
4373 }
4374 if (SWIG_arg_fail(2)) SWIG_fail;
4375 }
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 (arg1)->base_StartingKey(*arg2);
4379
4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 Py_INCREF(Py_None); resultobj = Py_None;
4384 return resultobj;
4385 fail:
4386 return NULL;
4387 }
4388
4389
4390 static PyObject *_wrap_PyGridCellEditor_base_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj;
4392 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4393 PyObject * obj0 = 0 ;
4394 char *kwnames[] = {
4395 (char *) "self", NULL
4396 };
4397
4398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_StartingClick",kwnames,&obj0)) goto fail;
4399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4400 if (SWIG_arg_fail(1)) SWIG_fail;
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 (arg1)->base_StartingClick();
4404
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 Py_INCREF(Py_None); resultobj = Py_None;
4409 return resultobj;
4410 fail:
4411 return NULL;
4412 }
4413
4414
4415 static PyObject *_wrap_PyGridCellEditor_base_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj;
4417 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4418 wxKeyEvent *arg2 = 0 ;
4419 PyObject * obj0 = 0 ;
4420 PyObject * obj1 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "self",(char *) "event", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(1)) SWIG_fail;
4428 {
4429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4430 if (SWIG_arg_fail(2)) SWIG_fail;
4431 if (arg2 == NULL) {
4432 SWIG_null_ref("wxKeyEvent");
4433 }
4434 if (SWIG_arg_fail(2)) SWIG_fail;
4435 }
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 (arg1)->base_HandleReturn(*arg2);
4439
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 Py_INCREF(Py_None); resultobj = Py_None;
4444 return resultobj;
4445 fail:
4446 return NULL;
4447 }
4448
4449
4450 static PyObject *_wrap_PyGridCellEditor_base_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4451 PyObject *resultobj;
4452 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4453 PyObject * obj0 = 0 ;
4454 char *kwnames[] = {
4455 (char *) "self", NULL
4456 };
4457
4458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_Destroy",kwnames,&obj0)) goto fail;
4459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4460 if (SWIG_arg_fail(1)) SWIG_fail;
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 (arg1)->base_Destroy();
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 Py_INCREF(Py_None); resultobj = Py_None;
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_PyGridCellEditor_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4478 wxString *arg2 = 0 ;
4479 bool temp2 = false ;
4480 PyObject * obj0 = 0 ;
4481 PyObject * obj1 = 0 ;
4482 char *kwnames[] = {
4483 (char *) "self",(char *) "params", NULL
4484 };
4485
4486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
4487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4488 if (SWIG_arg_fail(1)) SWIG_fail;
4489 {
4490 arg2 = wxString_in_helper(obj1);
4491 if (arg2 == NULL) SWIG_fail;
4492 temp2 = true;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 (arg1)->base_SetParameters((wxString const &)*arg2);
4497
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 Py_INCREF(Py_None); resultobj = Py_None;
4502 {
4503 if (temp2)
4504 delete arg2;
4505 }
4506 return resultobj;
4507 fail:
4508 {
4509 if (temp2)
4510 delete arg2;
4511 }
4512 return NULL;
4513 }
4514
4515
4516 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4517 PyObject *obj;
4518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4519 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4520 Py_INCREF(obj);
4521 return Py_BuildValue((char *)"");
4522 }
4523 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxGridCellTextEditor *result;
4526 char *kwnames[] = {
4527 NULL
4528 };
4529
4530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4534
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4546 PyObject *resultobj;
4547 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4548 wxString result;
4549 PyObject * obj0 = 0 ;
4550 char *kwnames[] = {
4551 (char *) "self", NULL
4552 };
4553
4554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(1)) SWIG_fail;
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (arg1)->GetValue();
4560
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 #if wxUSE_UNICODE
4566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4567 #else
4568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4569 #endif
4570 }
4571 return resultobj;
4572 fail:
4573 return NULL;
4574 }
4575
4576
4577 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4578 PyObject *obj;
4579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4580 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4581 Py_INCREF(obj);
4582 return Py_BuildValue((char *)"");
4583 }
4584 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4585 PyObject *resultobj;
4586 int arg1 = (int) -1 ;
4587 int arg2 = (int) -1 ;
4588 wxGridCellNumberEditor *result;
4589 PyObject * obj0 = 0 ;
4590 PyObject * obj1 = 0 ;
4591 char *kwnames[] = {
4592 (char *) "min",(char *) "max", NULL
4593 };
4594
4595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4596 if (obj0) {
4597 {
4598 arg1 = (int)(SWIG_As_int(obj0));
4599 if (SWIG_arg_fail(1)) SWIG_fail;
4600 }
4601 }
4602 if (obj1) {
4603 {
4604 arg2 = (int)(SWIG_As_int(obj1));
4605 if (SWIG_arg_fail(2)) SWIG_fail;
4606 }
4607 }
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4625 wxString result;
4626 PyObject * obj0 = 0 ;
4627 char *kwnames[] = {
4628 (char *) "self", NULL
4629 };
4630
4631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4633 if (SWIG_arg_fail(1)) SWIG_fail;
4634 {
4635 PyThreadState* __tstate = wxPyBeginAllowThreads();
4636 result = (arg1)->GetValue();
4637
4638 wxPyEndAllowThreads(__tstate);
4639 if (PyErr_Occurred()) SWIG_fail;
4640 }
4641 {
4642 #if wxUSE_UNICODE
4643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4644 #else
4645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4646 #endif
4647 }
4648 return resultobj;
4649 fail:
4650 return NULL;
4651 }
4652
4653
4654 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4655 PyObject *obj;
4656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4657 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4658 Py_INCREF(obj);
4659 return Py_BuildValue((char *)"");
4660 }
4661 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj;
4663 int arg1 = (int) -1 ;
4664 int arg2 = (int) -1 ;
4665 wxGridCellFloatEditor *result;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "width",(char *) "precision", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4673 if (obj0) {
4674 {
4675 arg1 = (int)(SWIG_As_int(obj0));
4676 if (SWIG_arg_fail(1)) SWIG_fail;
4677 }
4678 }
4679 if (obj1) {
4680 {
4681 arg2 = (int)(SWIG_As_int(obj1));
4682 if (SWIG_arg_fail(2)) SWIG_fail;
4683 }
4684 }
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4688
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj;
4701 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4702 wxString result;
4703 PyObject * obj0 = 0 ;
4704 char *kwnames[] = {
4705 (char *) "self", NULL
4706 };
4707
4708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4710 if (SWIG_arg_fail(1)) SWIG_fail;
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 result = (arg1)->GetValue();
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 {
4719 #if wxUSE_UNICODE
4720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4721 #else
4722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4723 #endif
4724 }
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4732 PyObject *obj;
4733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4734 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4735 Py_INCREF(obj);
4736 return Py_BuildValue((char *)"");
4737 }
4738 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4739 PyObject *resultobj;
4740 wxGridCellBoolEditor *result;
4741 char *kwnames[] = {
4742 NULL
4743 };
4744
4745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4749
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj;
4762 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4763 wxString result;
4764 PyObject * obj0 = 0 ;
4765 char *kwnames[] = {
4766 (char *) "self", NULL
4767 };
4768
4769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4771 if (SWIG_arg_fail(1)) SWIG_fail;
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (arg1)->GetValue();
4775
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 {
4780 #if wxUSE_UNICODE
4781 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4782 #else
4783 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4784 #endif
4785 }
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
4793 PyObject *obj;
4794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4795 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
4796 Py_INCREF(obj);
4797 return Py_BuildValue((char *)"");
4798 }
4799 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj;
4801 int arg1 = (int) 0 ;
4802 wxString *arg2 = (wxString *) NULL ;
4803 bool arg3 = (bool) false ;
4804 wxGridCellChoiceEditor *result;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char *kwnames[] = {
4808 (char *) "choices",(char *) "allowOthers", NULL
4809 };
4810
4811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
4812 if (obj0) {
4813 {
4814 arg1 = PyList_Size(obj0);
4815 arg2 = wxString_LIST_helper(obj0);
4816 if (arg2 == NULL) SWIG_fail;
4817 }
4818 }
4819 if (obj1) {
4820 {
4821 arg3 = (bool)(SWIG_As_bool(obj1));
4822 if (SWIG_arg_fail(3)) SWIG_fail;
4823 }
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
4828
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
4833 {
4834 if (arg2) delete [] arg2;
4835 }
4836 return resultobj;
4837 fail:
4838 {
4839 if (arg2) delete [] arg2;
4840 }
4841 return NULL;
4842 }
4843
4844
4845 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj;
4847 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
4848 wxString result;
4849 PyObject * obj0 = 0 ;
4850 char *kwnames[] = {
4851 (char *) "self", NULL
4852 };
4853
4854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
4855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
4856 if (SWIG_arg_fail(1)) SWIG_fail;
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 result = (arg1)->GetValue();
4860
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 {
4865 #if wxUSE_UNICODE
4866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4867 #else
4868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4869 #endif
4870 }
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
4878 PyObject *obj;
4879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4880 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
4881 Py_INCREF(obj);
4882 return Py_BuildValue((char *)"");
4883 }
4884 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxString const &arg1_defvalue = wxPyEmptyString ;
4887 wxString *arg1 = (wxString *) &arg1_defvalue ;
4888 wxGridCellEnumEditor *result;
4889 bool temp1 = false ;
4890 PyObject * obj0 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "choices", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
4896 if (obj0) {
4897 {
4898 arg1 = wxString_in_helper(obj0);
4899 if (arg1 == NULL) SWIG_fail;
4900 temp1 = true;
4901 }
4902 }
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
4906
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
4911 {
4912 if (temp1)
4913 delete arg1;
4914 }
4915 return resultobj;
4916 fail:
4917 {
4918 if (temp1)
4919 delete arg1;
4920 }
4921 return NULL;
4922 }
4923
4924
4925 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj;
4927 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
4928 wxString result;
4929 PyObject * obj0 = 0 ;
4930 char *kwnames[] = {
4931 (char *) "self", NULL
4932 };
4933
4934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
4935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
4936 if (SWIG_arg_fail(1)) SWIG_fail;
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 result = (arg1)->GetValue();
4940
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 {
4945 #if wxUSE_UNICODE
4946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4947 #else
4948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4949 #endif
4950 }
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
4958 PyObject *obj;
4959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4960 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
4961 Py_INCREF(obj);
4962 return Py_BuildValue((char *)"");
4963 }
4964 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj;
4966 wxGridCellAutoWrapStringEditor *result;
4967 char *kwnames[] = {
4968 NULL
4969 };
4970
4971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
4975
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj;
4988 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
4989 wxString result;
4990 PyObject * obj0 = 0 ;
4991 char *kwnames[] = {
4992 (char *) "self", NULL
4993 };
4994
4995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
4996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
4997 if (SWIG_arg_fail(1)) SWIG_fail;
4998 {
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (arg1)->GetValue();
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 {
5006 #if wxUSE_UNICODE
5007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5008 #else
5009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5010 #endif
5011 }
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5019 PyObject *obj;
5020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5021 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5022 Py_INCREF(obj);
5023 return Py_BuildValue((char *)"");
5024 }
5025 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5026 PyObject *resultobj;
5027 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5028 PyObject *arg2 = (PyObject *) 0 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self",(char *) "_self", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 arg2 = obj1;
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 wxGridCellAttr__setOORInfo(arg1,arg2);
5042
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 Py_INCREF(Py_None); resultobj = Py_None;
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5054 PyObject *resultobj;
5055 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5056 wxGridCellAttr *result;
5057 PyObject * obj0 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "attrDefault", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5063 if (obj0) {
5064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5065 if (SWIG_arg_fail(1)) SWIG_fail;
5066 }
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5070
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 {
5075 resultobj = wxPyMake_wxGridCellAttr(result, 1);
5076 }
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5086 wxGridCellAttr *result;
5087 PyObject * obj0 = 0 ;
5088 char *kwnames[] = {
5089 (char *) "self", NULL
5090 };
5091
5092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5094 if (SWIG_arg_fail(1)) SWIG_fail;
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = wxPyMake_wxGridCellAttr(result, 0);
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj;
5113 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5114 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5115 PyObject * obj0 = 0 ;
5116 PyObject * obj1 = 0 ;
5117 char *kwnames[] = {
5118 (char *) "self",(char *) "mergefrom", NULL
5119 };
5120
5121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(2)) SWIG_fail;
5126 {
5127 PyThreadState* __tstate = wxPyBeginAllowThreads();
5128 (arg1)->MergeWith(arg2);
5129
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 Py_INCREF(Py_None); resultobj = Py_None;
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5141 PyObject *resultobj;
5142 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5143 PyObject * obj0 = 0 ;
5144 char *kwnames[] = {
5145 (char *) "self", NULL
5146 };
5147
5148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5150 if (SWIG_arg_fail(1)) SWIG_fail;
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 (arg1)->IncRef();
5154
5155 wxPyEndAllowThreads(__tstate);
5156 if (PyErr_Occurred()) SWIG_fail;
5157 }
5158 Py_INCREF(Py_None); resultobj = Py_None;
5159 return resultobj;
5160 fail:
5161 return NULL;
5162 }
5163
5164
5165 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5166 PyObject *resultobj;
5167 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5168 PyObject * obj0 = 0 ;
5169 char *kwnames[] = {
5170 (char *) "self", NULL
5171 };
5172
5173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5175 if (SWIG_arg_fail(1)) SWIG_fail;
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 (arg1)->DecRef();
5179
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 Py_INCREF(Py_None); resultobj = Py_None;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj;
5192 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5193 wxColour *arg2 = 0 ;
5194 wxColour temp2 ;
5195 PyObject * obj0 = 0 ;
5196 PyObject * obj1 = 0 ;
5197 char *kwnames[] = {
5198 (char *) "self",(char *) "colText", NULL
5199 };
5200
5201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5203 if (SWIG_arg_fail(1)) SWIG_fail;
5204 {
5205 arg2 = &temp2;
5206 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5207 }
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 (arg1)->SetTextColour((wxColour const &)*arg2);
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 Py_INCREF(Py_None); resultobj = Py_None;
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj;
5224 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5225 wxColour *arg2 = 0 ;
5226 wxColour temp2 ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 char *kwnames[] = {
5230 (char *) "self",(char *) "colBack", NULL
5231 };
5232
5233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5235 if (SWIG_arg_fail(1)) SWIG_fail;
5236 {
5237 arg2 = &temp2;
5238 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5239 }
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5243
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 Py_INCREF(Py_None); resultobj = Py_None;
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 static PyObject *_wrap_GridCellAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj;
5256 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5257 wxFont *arg2 = 0 ;
5258 PyObject * obj0 = 0 ;
5259 PyObject * obj1 = 0 ;
5260 char *kwnames[] = {
5261 (char *) "self",(char *) "font", NULL
5262 };
5263
5264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5266 if (SWIG_arg_fail(1)) SWIG_fail;
5267 {
5268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5269 if (SWIG_arg_fail(2)) SWIG_fail;
5270 if (arg2 == NULL) {
5271 SWIG_null_ref("wxFont");
5272 }
5273 if (SWIG_arg_fail(2)) SWIG_fail;
5274 }
5275 {
5276 PyThreadState* __tstate = wxPyBeginAllowThreads();
5277 (arg1)->SetFont((wxFont const &)*arg2);
5278
5279 wxPyEndAllowThreads(__tstate);
5280 if (PyErr_Occurred()) SWIG_fail;
5281 }
5282 Py_INCREF(Py_None); resultobj = Py_None;
5283 return resultobj;
5284 fail:
5285 return NULL;
5286 }
5287
5288
5289 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5290 PyObject *resultobj;
5291 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5292 int arg2 ;
5293 int arg3 ;
5294 PyObject * obj0 = 0 ;
5295 PyObject * obj1 = 0 ;
5296 PyObject * obj2 = 0 ;
5297 char *kwnames[] = {
5298 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5299 };
5300
5301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5303 if (SWIG_arg_fail(1)) SWIG_fail;
5304 {
5305 arg2 = (int)(SWIG_As_int(obj1));
5306 if (SWIG_arg_fail(2)) SWIG_fail;
5307 }
5308 {
5309 arg3 = (int)(SWIG_As_int(obj2));
5310 if (SWIG_arg_fail(3)) SWIG_fail;
5311 }
5312 {
5313 PyThreadState* __tstate = wxPyBeginAllowThreads();
5314 (arg1)->SetAlignment(arg2,arg3);
5315
5316 wxPyEndAllowThreads(__tstate);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 Py_INCREF(Py_None); resultobj = Py_None;
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5327 PyObject *resultobj;
5328 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5329 int arg2 ;
5330 int arg3 ;
5331 PyObject * obj0 = 0 ;
5332 PyObject * obj1 = 0 ;
5333 PyObject * obj2 = 0 ;
5334 char *kwnames[] = {
5335 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5336 };
5337
5338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5340 if (SWIG_arg_fail(1)) SWIG_fail;
5341 {
5342 arg2 = (int)(SWIG_As_int(obj1));
5343 if (SWIG_arg_fail(2)) SWIG_fail;
5344 }
5345 {
5346 arg3 = (int)(SWIG_As_int(obj2));
5347 if (SWIG_arg_fail(3)) SWIG_fail;
5348 }
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 (arg1)->SetSize(arg2,arg3);
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 Py_INCREF(Py_None); resultobj = Py_None;
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj;
5365 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5366 bool arg2 = (bool) true ;
5367 PyObject * obj0 = 0 ;
5368 PyObject * obj1 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self",(char *) "allow", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 if (obj1) {
5377 {
5378 arg2 = (bool)(SWIG_As_bool(obj1));
5379 if (SWIG_arg_fail(2)) SWIG_fail;
5380 }
5381 }
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 (arg1)->SetOverflow(arg2);
5385
5386 wxPyEndAllowThreads(__tstate);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 Py_INCREF(Py_None); resultobj = Py_None;
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj;
5398 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5399 bool arg2 = (bool) true ;
5400 PyObject * obj0 = 0 ;
5401 PyObject * obj1 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self",(char *) "isReadOnly", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 if (obj1) {
5410 {
5411 arg2 = (bool)(SWIG_As_bool(obj1));
5412 if (SWIG_arg_fail(2)) SWIG_fail;
5413 }
5414 }
5415 {
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 (arg1)->SetReadOnly(arg2);
5418
5419 wxPyEndAllowThreads(__tstate);
5420 if (PyErr_Occurred()) SWIG_fail;
5421 }
5422 Py_INCREF(Py_None); resultobj = Py_None;
5423 return resultobj;
5424 fail:
5425 return NULL;
5426 }
5427
5428
5429 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5430 PyObject *resultobj;
5431 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5432 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 char *kwnames[] = {
5436 (char *) "self",(char *) "renderer", NULL
5437 };
5438
5439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5441 if (SWIG_arg_fail(1)) SWIG_fail;
5442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5443 if (SWIG_arg_fail(2)) SWIG_fail;
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 (arg1)->SetRenderer(arg2);
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 Py_INCREF(Py_None); resultobj = Py_None;
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj;
5460 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5461 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5462 PyObject * obj0 = 0 ;
5463 PyObject * obj1 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self",(char *) "editor", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5472 if (SWIG_arg_fail(2)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 (arg1)->SetEditor(arg2);
5476
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 Py_INCREF(Py_None); resultobj = Py_None;
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5490 wxGridCellAttr::wxAttrKind arg2 ;
5491 PyObject * obj0 = 0 ;
5492 PyObject * obj1 = 0 ;
5493 char *kwnames[] = {
5494 (char *) "self",(char *) "kind", NULL
5495 };
5496
5497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5499 if (SWIG_arg_fail(1)) SWIG_fail;
5500 {
5501 arg2 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj1));
5502 if (SWIG_arg_fail(2)) SWIG_fail;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 (arg1)->SetKind((wxGridCellAttr::wxAttrKind )arg2);
5507
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 Py_INCREF(Py_None); resultobj = Py_None;
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5521 bool result;
5522 PyObject * obj0 = 0 ;
5523 char *kwnames[] = {
5524 (char *) "self", NULL
5525 };
5526
5527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5529 if (SWIG_arg_fail(1)) SWIG_fail;
5530 {
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5533
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5539 }
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj;
5548 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5549 bool result;
5550 PyObject * obj0 = 0 ;
5551 char *kwnames[] = {
5552 (char *) "self", NULL
5553 };
5554
5555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5557 if (SWIG_arg_fail(1)) SWIG_fail;
5558 {
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5561
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 {
5566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5567 }
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5577 bool result;
5578 PyObject * obj0 = 0 ;
5579 char *kwnames[] = {
5580 (char *) "self", NULL
5581 };
5582
5583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5585 if (SWIG_arg_fail(1)) SWIG_fail;
5586 {
5587 PyThreadState* __tstate = wxPyBeginAllowThreads();
5588 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5589
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 {
5594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5595 }
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj;
5604 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5605 bool result;
5606 PyObject * obj0 = 0 ;
5607 char *kwnames[] = {
5608 (char *) "self", NULL
5609 };
5610
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5613 if (SWIG_arg_fail(1)) SWIG_fail;
5614 {
5615 PyThreadState* __tstate = wxPyBeginAllowThreads();
5616 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5617
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 {
5622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5623 }
5624 return resultobj;
5625 fail:
5626 return NULL;
5627 }
5628
5629
5630 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5631 PyObject *resultobj;
5632 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5633 bool result;
5634 PyObject * obj0 = 0 ;
5635 char *kwnames[] = {
5636 (char *) "self", NULL
5637 };
5638
5639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5641 if (SWIG_arg_fail(1)) SWIG_fail;
5642 {
5643 PyThreadState* __tstate = wxPyBeginAllowThreads();
5644 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5645
5646 wxPyEndAllowThreads(__tstate);
5647 if (PyErr_Occurred()) SWIG_fail;
5648 }
5649 {
5650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5651 }
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5661 bool result;
5662 PyObject * obj0 = 0 ;
5663 char *kwnames[] = {
5664 (char *) "self", NULL
5665 };
5666
5667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5669 if (SWIG_arg_fail(1)) SWIG_fail;
5670 {
5671 PyThreadState* __tstate = wxPyBeginAllowThreads();
5672 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5673
5674 wxPyEndAllowThreads(__tstate);
5675 if (PyErr_Occurred()) SWIG_fail;
5676 }
5677 {
5678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5679 }
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5689 bool result;
5690 PyObject * obj0 = 0 ;
5691 char *kwnames[] = {
5692 (char *) "self", NULL
5693 };
5694
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5697 if (SWIG_arg_fail(1)) SWIG_fail;
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 {
5706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5707 }
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj;
5716 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5717 bool result;
5718 PyObject * obj0 = 0 ;
5719 char *kwnames[] = {
5720 (char *) "self", NULL
5721 };
5722
5723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5725 if (SWIG_arg_fail(1)) SWIG_fail;
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 {
5734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5735 }
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj;
5744 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5745 wxColour result;
5746 PyObject * obj0 = 0 ;
5747 char *kwnames[] = {
5748 (char *) "self", NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5753 if (SWIG_arg_fail(1)) SWIG_fail;
5754 {
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 wxColour * resultptr;
5763 resultptr = new wxColour((wxColour &)(result));
5764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5765 }
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5775 wxColour result;
5776 PyObject * obj0 = 0 ;
5777 char *kwnames[] = {
5778 (char *) "self", NULL
5779 };
5780
5781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
5782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5783 if (SWIG_arg_fail(1)) SWIG_fail;
5784 {
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 {
5792 wxColour * resultptr;
5793 resultptr = new wxColour((wxColour &)(result));
5794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5795 }
5796 return resultobj;
5797 fail:
5798 return NULL;
5799 }
5800
5801
5802 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5803 PyObject *resultobj;
5804 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5805 wxFont result;
5806 PyObject * obj0 = 0 ;
5807 char *kwnames[] = {
5808 (char *) "self", NULL
5809 };
5810
5811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
5812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5813 if (SWIG_arg_fail(1)) SWIG_fail;
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = ((wxGridCellAttr const *)arg1)->GetFont();
5817
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 wxFont * resultptr;
5823 resultptr = new wxFont((wxFont &)(result));
5824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj;
5834 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5835 int *arg2 = (int *) 0 ;
5836 int *arg3 = (int *) 0 ;
5837 int temp2 ;
5838 int res2 = 0 ;
5839 int temp3 ;
5840 int res3 = 0 ;
5841 PyObject * obj0 = 0 ;
5842 char *kwnames[] = {
5843 (char *) "self", NULL
5844 };
5845
5846 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5847 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
5849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5850 if (SWIG_arg_fail(1)) SWIG_fail;
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5860 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5861 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5862 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5863 return resultobj;
5864 fail:
5865 return NULL;
5866 }
5867
5868
5869 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5870 PyObject *resultobj;
5871 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5872 int *arg2 = (int *) 0 ;
5873 int *arg3 = (int *) 0 ;
5874 int temp2 ;
5875 int res2 = 0 ;
5876 int temp3 ;
5877 int res3 = 0 ;
5878 PyObject * obj0 = 0 ;
5879 char *kwnames[] = {
5880 (char *) "self", NULL
5881 };
5882
5883 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5884 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
5886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5887 if (SWIG_arg_fail(1)) SWIG_fail;
5888 {
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
5891
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 Py_INCREF(Py_None); resultobj = Py_None;
5896 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5897 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5898 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5899 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj;
5908 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5909 bool result;
5910 PyObject * obj0 = 0 ;
5911 char *kwnames[] = {
5912 (char *) "self", NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
5916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5917 if (SWIG_arg_fail(1)) SWIG_fail;
5918 {
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 {
5926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5927 }
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj;
5936 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5937 wxGrid *arg2 = (wxGrid *) 0 ;
5938 int arg3 ;
5939 int arg4 ;
5940 wxGridCellRenderer *result;
5941 PyObject * obj0 = 0 ;
5942 PyObject * obj1 = 0 ;
5943 PyObject * obj2 = 0 ;
5944 PyObject * obj3 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5953 if (SWIG_arg_fail(2)) SWIG_fail;
5954 {
5955 arg3 = (int)(SWIG_As_int(obj2));
5956 if (SWIG_arg_fail(3)) SWIG_fail;
5957 }
5958 {
5959 arg4 = (int)(SWIG_As_int(obj3));
5960 if (SWIG_arg_fail(4)) SWIG_fail;
5961 }
5962 {
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
5965
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
5971 }
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj;
5980 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5981 wxGrid *arg2 = (wxGrid *) 0 ;
5982 int arg3 ;
5983 int arg4 ;
5984 wxGridCellEditor *result;
5985 PyObject * obj0 = 0 ;
5986 PyObject * obj1 = 0 ;
5987 PyObject * obj2 = 0 ;
5988 PyObject * obj3 = 0 ;
5989 char *kwnames[] = {
5990 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5995 if (SWIG_arg_fail(1)) SWIG_fail;
5996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5997 if (SWIG_arg_fail(2)) SWIG_fail;
5998 {
5999 arg3 = (int)(SWIG_As_int(obj2));
6000 if (SWIG_arg_fail(3)) SWIG_fail;
6001 }
6002 {
6003 arg4 = (int)(SWIG_As_int(obj3));
6004 if (SWIG_arg_fail(4)) SWIG_fail;
6005 }
6006 {
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6009
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 resultobj = wxPyMake_wxGridCellEditor(result, 0);
6015 }
6016 return resultobj;
6017 fail:
6018 return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6023 PyObject *resultobj;
6024 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6025 bool result;
6026 PyObject * obj0 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "self", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6033 if (SWIG_arg_fail(1)) SWIG_fail;
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 {
6042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6043 }
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6053 wxGridCellAttr::wxAttrKind result;
6054 PyObject * obj0 = 0 ;
6055 char *kwnames[] = {
6056 (char *) "self", NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6061 if (SWIG_arg_fail(1)) SWIG_fail;
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = SWIG_From_int((result));
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj;
6078 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6079 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char *kwnames[] = {
6083 (char *) "self",(char *) "defAttr", NULL
6084 };
6085
6086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6088 if (SWIG_arg_fail(1)) SWIG_fail;
6089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6090 if (SWIG_arg_fail(2)) SWIG_fail;
6091 {
6092 PyThreadState* __tstate = wxPyBeginAllowThreads();
6093 (arg1)->SetDefAttr(arg2);
6094
6095 wxPyEndAllowThreads(__tstate);
6096 if (PyErr_Occurred()) SWIG_fail;
6097 }
6098 Py_INCREF(Py_None); resultobj = Py_None;
6099 return resultobj;
6100 fail:
6101 return NULL;
6102 }
6103
6104
6105 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6106 PyObject *obj;
6107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6108 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6109 Py_INCREF(obj);
6110 return Py_BuildValue((char *)"");
6111 }
6112 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6113 PyObject *resultobj;
6114 wxGridCellAttrProvider *result;
6115 char *kwnames[] = {
6116 NULL
6117 };
6118
6119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6120 {
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6123
6124 wxPyEndAllowThreads(__tstate);
6125 if (PyErr_Occurred()) SWIG_fail;
6126 }
6127 {
6128 resultobj = wxPyMake_wxGridCellAttrProvider(result, 1);
6129 }
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6139 PyObject *arg2 = (PyObject *) 0 ;
6140 PyObject * obj0 = 0 ;
6141 PyObject * obj1 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self",(char *) "_self", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 arg2 = obj1;
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6153
6154 wxPyEndAllowThreads(__tstate);
6155 if (PyErr_Occurred()) SWIG_fail;
6156 }
6157 Py_INCREF(Py_None); resultobj = Py_None;
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6165 PyObject *resultobj;
6166 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6167 int arg2 ;
6168 int arg3 ;
6169 wxGridCellAttr::wxAttrKind arg4 ;
6170 wxGridCellAttr *result;
6171 PyObject * obj0 = 0 ;
6172 PyObject * obj1 = 0 ;
6173 PyObject * obj2 = 0 ;
6174 PyObject * obj3 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 {
6183 arg2 = (int)(SWIG_As_int(obj1));
6184 if (SWIG_arg_fail(2)) SWIG_fail;
6185 }
6186 {
6187 arg3 = (int)(SWIG_As_int(obj2));
6188 if (SWIG_arg_fail(3)) SWIG_fail;
6189 }
6190 {
6191 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6192 if (SWIG_arg_fail(4)) SWIG_fail;
6193 }
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6197
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 {
6202 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6203 }
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6213 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6214 int arg3 ;
6215 int arg4 ;
6216 PyObject * obj0 = 0 ;
6217 PyObject * obj1 = 0 ;
6218 PyObject * obj2 = 0 ;
6219 PyObject * obj3 = 0 ;
6220 char *kwnames[] = {
6221 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6222 };
6223
6224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6228 if (SWIG_arg_fail(2)) SWIG_fail;
6229 {
6230 arg3 = (int)(SWIG_As_int(obj2));
6231 if (SWIG_arg_fail(3)) SWIG_fail;
6232 }
6233 {
6234 arg4 = (int)(SWIG_As_int(obj3));
6235 if (SWIG_arg_fail(4)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 (arg1)->SetAttr(arg2,arg3,arg4);
6240
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 Py_INCREF(Py_None); resultobj = Py_None;
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6252 PyObject *resultobj;
6253 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6254 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6255 int arg3 ;
6256 PyObject * obj0 = 0 ;
6257 PyObject * obj1 = 0 ;
6258 PyObject * obj2 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self",(char *) "attr",(char *) "row", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(2)) SWIG_fail;
6268 {
6269 arg3 = (int)(SWIG_As_int(obj2));
6270 if (SWIG_arg_fail(3)) SWIG_fail;
6271 }
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 (arg1)->SetRowAttr(arg2,arg3);
6275
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 Py_INCREF(Py_None); resultobj = Py_None;
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj;
6288 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6289 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6290 int arg3 ;
6291 PyObject * obj0 = 0 ;
6292 PyObject * obj1 = 0 ;
6293 PyObject * obj2 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self",(char *) "attr",(char *) "col", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6302 if (SWIG_arg_fail(2)) SWIG_fail;
6303 {
6304 arg3 = (int)(SWIG_As_int(obj2));
6305 if (SWIG_arg_fail(3)) SWIG_fail;
6306 }
6307 {
6308 PyThreadState* __tstate = wxPyBeginAllowThreads();
6309 (arg1)->SetColAttr(arg2,arg3);
6310
6311 wxPyEndAllowThreads(__tstate);
6312 if (PyErr_Occurred()) SWIG_fail;
6313 }
6314 Py_INCREF(Py_None); resultobj = Py_None;
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj;
6323 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6324 size_t arg2 ;
6325 int arg3 ;
6326 PyObject * obj0 = 0 ;
6327 PyObject * obj1 = 0 ;
6328 PyObject * obj2 = 0 ;
6329 char *kwnames[] = {
6330 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6331 };
6332
6333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6335 if (SWIG_arg_fail(1)) SWIG_fail;
6336 {
6337 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6338 if (SWIG_arg_fail(2)) SWIG_fail;
6339 }
6340 {
6341 arg3 = (int)(SWIG_As_int(obj2));
6342 if (SWIG_arg_fail(3)) SWIG_fail;
6343 }
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 (arg1)->UpdateAttrRows(arg2,arg3);
6347
6348 wxPyEndAllowThreads(__tstate);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 Py_INCREF(Py_None); resultobj = Py_None;
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6359 PyObject *resultobj;
6360 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6361 size_t arg2 ;
6362 int arg3 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 PyObject * obj2 = 0 ;
6366 char *kwnames[] = {
6367 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6368 };
6369
6370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6372 if (SWIG_arg_fail(1)) SWIG_fail;
6373 {
6374 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6375 if (SWIG_arg_fail(2)) SWIG_fail;
6376 }
6377 {
6378 arg3 = (int)(SWIG_As_int(obj2));
6379 if (SWIG_arg_fail(3)) SWIG_fail;
6380 }
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 (arg1)->UpdateAttrCols(arg2,arg3);
6384
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 Py_INCREF(Py_None); resultobj = Py_None;
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6396 PyObject *obj;
6397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6398 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6399 Py_INCREF(obj);
6400 return Py_BuildValue((char *)"");
6401 }
6402 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxPyGridCellAttrProvider *result;
6405 char *kwnames[] = {
6406 NULL
6407 };
6408
6409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6427 PyObject *arg2 = (PyObject *) 0 ;
6428 PyObject *arg3 = (PyObject *) 0 ;
6429 PyObject * obj0 = 0 ;
6430 PyObject * obj1 = 0 ;
6431 PyObject * obj2 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self",(char *) "self",(char *) "_class", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 arg2 = obj1;
6440 arg3 = obj2;
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 (arg1)->_setCallbackInfo(arg2,arg3);
6444
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 Py_INCREF(Py_None); resultobj = Py_None;
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 static PyObject *_wrap_PyGridCellAttrProvider_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj;
6457 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6458 int arg2 ;
6459 int arg3 ;
6460 wxGridCellAttr::wxAttrKind arg4 ;
6461 wxGridCellAttr *result;
6462 PyObject * obj0 = 0 ;
6463 PyObject * obj1 = 0 ;
6464 PyObject * obj2 = 0 ;
6465 PyObject * obj3 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 {
6474 arg2 = (int)(SWIG_As_int(obj1));
6475 if (SWIG_arg_fail(2)) SWIG_fail;
6476 }
6477 {
6478 arg3 = (int)(SWIG_As_int(obj2));
6479 if (SWIG_arg_fail(3)) SWIG_fail;
6480 }
6481 {
6482 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6483 if (SWIG_arg_fail(4)) SWIG_fail;
6484 }
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 {
6493 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6494 }
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 static PyObject *_wrap_PyGridCellAttrProvider_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6502 PyObject *resultobj;
6503 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6504 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6505 int arg3 ;
6506 int arg4 ;
6507 PyObject * obj0 = 0 ;
6508 PyObject * obj1 = 0 ;
6509 PyObject * obj2 = 0 ;
6510 PyObject * obj3 = 0 ;
6511 char *kwnames[] = {
6512 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6513 };
6514
6515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6517 if (SWIG_arg_fail(1)) SWIG_fail;
6518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(2)) SWIG_fail;
6520 {
6521 arg3 = (int)(SWIG_As_int(obj2));
6522 if (SWIG_arg_fail(3)) SWIG_fail;
6523 }
6524 {
6525 arg4 = (int)(SWIG_As_int(obj3));
6526 if (SWIG_arg_fail(4)) SWIG_fail;
6527 }
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 (arg1)->base_SetAttr(arg2,arg3,arg4);
6531
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 Py_INCREF(Py_None); resultobj = Py_None;
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 static PyObject *_wrap_PyGridCellAttrProvider_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj;
6544 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6545 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6546 int arg3 ;
6547 PyObject * obj0 = 0 ;
6548 PyObject * obj1 = 0 ;
6549 PyObject * obj2 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self",(char *) "attr",(char *) "row", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6558 if (SWIG_arg_fail(2)) SWIG_fail;
6559 {
6560 arg3 = (int)(SWIG_As_int(obj2));
6561 if (SWIG_arg_fail(3)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 (arg1)->base_SetRowAttr(arg2,arg3);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 Py_INCREF(Py_None); resultobj = Py_None;
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 static PyObject *_wrap_PyGridCellAttrProvider_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6578 PyObject *resultobj;
6579 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6580 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6581 int arg3 ;
6582 PyObject * obj0 = 0 ;
6583 PyObject * obj1 = 0 ;
6584 PyObject * obj2 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self",(char *) "attr",(char *) "col", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6591 if (SWIG_arg_fail(1)) SWIG_fail;
6592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(2)) SWIG_fail;
6594 {
6595 arg3 = (int)(SWIG_As_int(obj2));
6596 if (SWIG_arg_fail(3)) SWIG_fail;
6597 }
6598 {
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 (arg1)->base_SetColAttr(arg2,arg3);
6601
6602 wxPyEndAllowThreads(__tstate);
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 Py_INCREF(Py_None); resultobj = Py_None;
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6613 PyObject *obj;
6614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6615 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6616 Py_INCREF(obj);
6617 return Py_BuildValue((char *)"");
6618 }
6619 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6622 PyObject *arg2 = (PyObject *) 0 ;
6623 PyObject * obj0 = 0 ;
6624 PyObject * obj1 = 0 ;
6625 char *kwnames[] = {
6626 (char *) "self",(char *) "_self", NULL
6627 };
6628
6629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6631 if (SWIG_arg_fail(1)) SWIG_fail;
6632 arg2 = obj1;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 wxGridTableBase__setOORInfo(arg1,arg2);
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 Py_INCREF(Py_None); resultobj = Py_None;
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6650 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6651 PyObject * obj0 = 0 ;
6652 PyObject * obj1 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self",(char *) "attrProvider", NULL
6655 };
6656
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(2)) SWIG_fail;
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 (arg1)->SetAttrProvider(arg2);
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 Py_INCREF(Py_None); resultobj = Py_None;
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6679 wxGridCellAttrProvider *result;
6680 PyObject * obj0 = 0 ;
6681 char *kwnames[] = {
6682 (char *) "self", NULL
6683 };
6684
6685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6687 if (SWIG_arg_fail(1)) SWIG_fail;
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6691
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 {
6696 resultobj = wxPyMake_wxGridCellAttrProvider(result, 0);
6697 }
6698 return resultobj;
6699 fail:
6700 return NULL;
6701 }
6702
6703
6704 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6705 PyObject *resultobj;
6706 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6707 wxGrid *arg2 = (wxGrid *) 0 ;
6708 PyObject * obj0 = 0 ;
6709 PyObject * obj1 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self",(char *) "grid", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6718 if (SWIG_arg_fail(2)) SWIG_fail;
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 (arg1)->SetView(arg2);
6722
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 Py_INCREF(Py_None); resultobj = Py_None;
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6734 PyObject *resultobj;
6735 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6736 wxGrid *result;
6737 PyObject * obj0 = 0 ;
6738 char *kwnames[] = {
6739 (char *) "self", NULL
6740 };
6741
6742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6744 if (SWIG_arg_fail(1)) SWIG_fail;
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6748
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 {
6753 resultobj = wxPyMake_wxObject(result, 0);
6754 }
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6762 PyObject *resultobj;
6763 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6764 int result;
6765 PyObject * obj0 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "self", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6772 if (SWIG_arg_fail(1)) SWIG_fail;
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 result = (int)(arg1)->GetNumberRows();
6776
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 {
6781 resultobj = SWIG_From_int((int)(result));
6782 }
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
6790 PyObject *resultobj;
6791 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6792 int result;
6793 PyObject * obj0 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 result = (int)(arg1)->GetNumberCols();
6804
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 {
6809 resultobj = SWIG_From_int((int)(result));
6810 }
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
6818 PyObject *resultobj;
6819 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6820 int arg2 ;
6821 int arg3 ;
6822 bool result;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self",(char *) "row",(char *) "col", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 arg2 = (int)(SWIG_As_int(obj1));
6835 if (SWIG_arg_fail(2)) SWIG_fail;
6836 }
6837 {
6838 arg3 = (int)(SWIG_As_int(obj2));
6839 if (SWIG_arg_fail(3)) SWIG_fail;
6840 }
6841 {
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 {
6849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6850 }
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj;
6859 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6860 int arg2 ;
6861 int arg3 ;
6862 wxString result;
6863 PyObject * obj0 = 0 ;
6864 PyObject * obj1 = 0 ;
6865 PyObject * obj2 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self",(char *) "row",(char *) "col", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 arg2 = (int)(SWIG_As_int(obj1));
6875 if (SWIG_arg_fail(2)) SWIG_fail;
6876 }
6877 {
6878 arg3 = (int)(SWIG_As_int(obj2));
6879 if (SWIG_arg_fail(3)) SWIG_fail;
6880 }
6881 {
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = (arg1)->GetValue(arg2,arg3);
6884
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 {
6889 #if wxUSE_UNICODE
6890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6891 #else
6892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6893 #endif
6894 }
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6902 PyObject *resultobj;
6903 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6904 int arg2 ;
6905 int arg3 ;
6906 wxString *arg4 = 0 ;
6907 bool temp4 = false ;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 PyObject * obj2 = 0 ;
6911 PyObject * obj3 = 0 ;
6912 char *kwnames[] = {
6913 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
6914 };
6915
6916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(1)) SWIG_fail;
6919 {
6920 arg2 = (int)(SWIG_As_int(obj1));
6921 if (SWIG_arg_fail(2)) SWIG_fail;
6922 }
6923 {
6924 arg3 = (int)(SWIG_As_int(obj2));
6925 if (SWIG_arg_fail(3)) SWIG_fail;
6926 }
6927 {
6928 arg4 = wxString_in_helper(obj3);
6929 if (arg4 == NULL) SWIG_fail;
6930 temp4 = true;
6931 }
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 Py_INCREF(Py_None); resultobj = Py_None;
6940 {
6941 if (temp4)
6942 delete arg4;
6943 }
6944 return resultobj;
6945 fail:
6946 {
6947 if (temp4)
6948 delete arg4;
6949 }
6950 return NULL;
6951 }
6952
6953
6954 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj;
6956 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6957 int arg2 ;
6958 int arg3 ;
6959 wxString result;
6960 PyObject * obj0 = 0 ;
6961 PyObject * obj1 = 0 ;
6962 PyObject * obj2 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "row",(char *) "col", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = (int)(SWIG_As_int(obj1));
6972 if (SWIG_arg_fail(2)) SWIG_fail;
6973 }
6974 {
6975 arg3 = (int)(SWIG_As_int(obj2));
6976 if (SWIG_arg_fail(3)) SWIG_fail;
6977 }
6978 {
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 result = (arg1)->GetTypeName(arg2,arg3);
6981
6982 wxPyEndAllowThreads(__tstate);
6983 if (PyErr_Occurred()) SWIG_fail;
6984 }
6985 {
6986 #if wxUSE_UNICODE
6987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6988 #else
6989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6990 #endif
6991 }
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj;
7000 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7001 int arg2 ;
7002 int arg3 ;
7003 wxString *arg4 = 0 ;
7004 bool result;
7005 bool temp4 = false ;
7006 PyObject * obj0 = 0 ;
7007 PyObject * obj1 = 0 ;
7008 PyObject * obj2 = 0 ;
7009 PyObject * obj3 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7016 if (SWIG_arg_fail(1)) SWIG_fail;
7017 {
7018 arg2 = (int)(SWIG_As_int(obj1));
7019 if (SWIG_arg_fail(2)) SWIG_fail;
7020 }
7021 {
7022 arg3 = (int)(SWIG_As_int(obj2));
7023 if (SWIG_arg_fail(3)) SWIG_fail;
7024 }
7025 {
7026 arg4 = wxString_in_helper(obj3);
7027 if (arg4 == NULL) SWIG_fail;
7028 temp4 = true;
7029 }
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7033
7034 wxPyEndAllowThreads(__tstate);
7035 if (PyErr_Occurred()) SWIG_fail;
7036 }
7037 {
7038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7039 }
7040 {
7041 if (temp4)
7042 delete arg4;
7043 }
7044 return resultobj;
7045 fail:
7046 {
7047 if (temp4)
7048 delete arg4;
7049 }
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7057 int arg2 ;
7058 int arg3 ;
7059 wxString *arg4 = 0 ;
7060 bool result;
7061 bool temp4 = false ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 PyObject * obj2 = 0 ;
7065 PyObject * obj3 = 0 ;
7066 char *kwnames[] = {
7067 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7068 };
7069
7070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7072 if (SWIG_arg_fail(1)) SWIG_fail;
7073 {
7074 arg2 = (int)(SWIG_As_int(obj1));
7075 if (SWIG_arg_fail(2)) SWIG_fail;
7076 }
7077 {
7078 arg3 = (int)(SWIG_As_int(obj2));
7079 if (SWIG_arg_fail(3)) SWIG_fail;
7080 }
7081 {
7082 arg4 = wxString_in_helper(obj3);
7083 if (arg4 == NULL) SWIG_fail;
7084 temp4 = true;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7089
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 {
7094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7095 }
7096 {
7097 if (temp4)
7098 delete arg4;
7099 }
7100 return resultobj;
7101 fail:
7102 {
7103 if (temp4)
7104 delete arg4;
7105 }
7106 return NULL;
7107 }
7108
7109
7110 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7111 PyObject *resultobj;
7112 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7113 int arg2 ;
7114 int arg3 ;
7115 long result;
7116 PyObject * obj0 = 0 ;
7117 PyObject * obj1 = 0 ;
7118 PyObject * obj2 = 0 ;
7119 char *kwnames[] = {
7120 (char *) "self",(char *) "row",(char *) "col", NULL
7121 };
7122
7123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7125 if (SWIG_arg_fail(1)) SWIG_fail;
7126 {
7127 arg2 = (int)(SWIG_As_int(obj1));
7128 if (SWIG_arg_fail(2)) SWIG_fail;
7129 }
7130 {
7131 arg3 = (int)(SWIG_As_int(obj2));
7132 if (SWIG_arg_fail(3)) SWIG_fail;
7133 }
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 {
7142 resultobj = SWIG_From_long((long)(result));
7143 }
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7151 PyObject *resultobj;
7152 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7153 int arg2 ;
7154 int arg3 ;
7155 double result;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 PyObject * obj2 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self",(char *) "row",(char *) "col", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 arg2 = (int)(SWIG_As_int(obj1));
7168 if (SWIG_arg_fail(2)) SWIG_fail;
7169 }
7170 {
7171 arg3 = (int)(SWIG_As_int(obj2));
7172 if (SWIG_arg_fail(3)) SWIG_fail;
7173 }
7174 {
7175 PyThreadState* __tstate = wxPyBeginAllowThreads();
7176 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7177
7178 wxPyEndAllowThreads(__tstate);
7179 if (PyErr_Occurred()) SWIG_fail;
7180 }
7181 {
7182 resultobj = SWIG_From_double((double)(result));
7183 }
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7191 PyObject *resultobj;
7192 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7193 int arg2 ;
7194 int arg3 ;
7195 bool result;
7196 PyObject * obj0 = 0 ;
7197 PyObject * obj1 = 0 ;
7198 PyObject * obj2 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "self",(char *) "row",(char *) "col", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 {
7207 arg2 = (int)(SWIG_As_int(obj1));
7208 if (SWIG_arg_fail(2)) SWIG_fail;
7209 }
7210 {
7211 arg3 = (int)(SWIG_As_int(obj2));
7212 if (SWIG_arg_fail(3)) SWIG_fail;
7213 }
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7217
7218 wxPyEndAllowThreads(__tstate);
7219 if (PyErr_Occurred()) SWIG_fail;
7220 }
7221 {
7222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7223 }
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj;
7232 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7233 int arg2 ;
7234 int arg3 ;
7235 long arg4 ;
7236 PyObject * obj0 = 0 ;
7237 PyObject * obj1 = 0 ;
7238 PyObject * obj2 = 0 ;
7239 PyObject * obj3 = 0 ;
7240 char *kwnames[] = {
7241 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7242 };
7243
7244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7246 if (SWIG_arg_fail(1)) SWIG_fail;
7247 {
7248 arg2 = (int)(SWIG_As_int(obj1));
7249 if (SWIG_arg_fail(2)) SWIG_fail;
7250 }
7251 {
7252 arg3 = (int)(SWIG_As_int(obj2));
7253 if (SWIG_arg_fail(3)) SWIG_fail;
7254 }
7255 {
7256 arg4 = (long)(SWIG_As_long(obj3));
7257 if (SWIG_arg_fail(4)) SWIG_fail;
7258 }
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7262
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 Py_INCREF(Py_None); resultobj = Py_None;
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj;
7275 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7276 int arg2 ;
7277 int arg3 ;
7278 double arg4 ;
7279 PyObject * obj0 = 0 ;
7280 PyObject * obj1 = 0 ;
7281 PyObject * obj2 = 0 ;
7282 PyObject * obj3 = 0 ;
7283 char *kwnames[] = {
7284 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7285 };
7286
7287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7289 if (SWIG_arg_fail(1)) SWIG_fail;
7290 {
7291 arg2 = (int)(SWIG_As_int(obj1));
7292 if (SWIG_arg_fail(2)) SWIG_fail;
7293 }
7294 {
7295 arg3 = (int)(SWIG_As_int(obj2));
7296 if (SWIG_arg_fail(3)) SWIG_fail;
7297 }
7298 {
7299 arg4 = (double)(SWIG_As_double(obj3));
7300 if (SWIG_arg_fail(4)) SWIG_fail;
7301 }
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7305
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 Py_INCREF(Py_None); resultobj = Py_None;
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj;
7318 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7319 int arg2 ;
7320 int arg3 ;
7321 bool arg4 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 PyObject * obj2 = 0 ;
7325 PyObject * obj3 = 0 ;
7326 char *kwnames[] = {
7327 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7328 };
7329
7330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7332 if (SWIG_arg_fail(1)) SWIG_fail;
7333 {
7334 arg2 = (int)(SWIG_As_int(obj1));
7335 if (SWIG_arg_fail(2)) SWIG_fail;
7336 }
7337 {
7338 arg3 = (int)(SWIG_As_int(obj2));
7339 if (SWIG_arg_fail(3)) SWIG_fail;
7340 }
7341 {
7342 arg4 = (bool)(SWIG_As_bool(obj3));
7343 if (SWIG_arg_fail(4)) SWIG_fail;
7344 }
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7348
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 Py_INCREF(Py_None); resultobj = Py_None;
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7362 PyObject * obj0 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 (arg1)->Clear();
7373
7374 wxPyEndAllowThreads(__tstate);
7375 if (PyErr_Occurred()) SWIG_fail;
7376 }
7377 Py_INCREF(Py_None); resultobj = Py_None;
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj;
7386 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7387 size_t arg2 = (size_t) 0 ;
7388 size_t arg3 = (size_t) 1 ;
7389 bool result;
7390 PyObject * obj0 = 0 ;
7391 PyObject * obj1 = 0 ;
7392 PyObject * obj2 = 0 ;
7393 char *kwnames[] = {
7394 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7395 };
7396
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 if (obj1) {
7401 {
7402 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7403 if (SWIG_arg_fail(2)) SWIG_fail;
7404 }
7405 }
7406 if (obj2) {
7407 {
7408 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7409 if (SWIG_arg_fail(3)) SWIG_fail;
7410 }
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 result = (bool)(arg1)->InsertRows(arg2,arg3);
7415
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 {
7420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7421 }
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7431 size_t arg2 = (size_t) 1 ;
7432 bool result;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self",(char *) "numRows", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 if (obj1) {
7443 {
7444 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7445 if (SWIG_arg_fail(2)) SWIG_fail;
7446 }
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)(arg1)->AppendRows(arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj;
7466 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7467 size_t arg2 = (size_t) 0 ;
7468 size_t arg3 = (size_t) 1 ;
7469 bool result;
7470 PyObject * obj0 = 0 ;
7471 PyObject * obj1 = 0 ;
7472 PyObject * obj2 = 0 ;
7473 char *kwnames[] = {
7474 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7475 };
7476
7477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7479 if (SWIG_arg_fail(1)) SWIG_fail;
7480 if (obj1) {
7481 {
7482 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7483 if (SWIG_arg_fail(2)) SWIG_fail;
7484 }
7485 }
7486 if (obj2) {
7487 {
7488 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7489 if (SWIG_arg_fail(3)) SWIG_fail;
7490 }
7491 }
7492 {
7493 PyThreadState* __tstate = wxPyBeginAllowThreads();
7494 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7495
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 {
7500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7501 }
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj;
7510 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7511 size_t arg2 = (size_t) 0 ;
7512 size_t arg3 = (size_t) 1 ;
7513 bool result;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 PyObject * obj2 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7523 if (SWIG_arg_fail(1)) SWIG_fail;
7524 if (obj1) {
7525 {
7526 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7527 if (SWIG_arg_fail(2)) SWIG_fail;
7528 }
7529 }
7530 if (obj2) {
7531 {
7532 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7533 if (SWIG_arg_fail(3)) SWIG_fail;
7534 }
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 result = (bool)(arg1)->InsertCols(arg2,arg3);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 {
7544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7545 }
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj;
7554 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7555 size_t arg2 = (size_t) 1 ;
7556 bool result;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 char *kwnames[] = {
7560 (char *) "self",(char *) "numCols", NULL
7561 };
7562
7563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(1)) SWIG_fail;
7566 if (obj1) {
7567 {
7568 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 }
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 result = (bool)(arg1)->AppendCols(arg2);
7575
7576 wxPyEndAllowThreads(__tstate);
7577 if (PyErr_Occurred()) SWIG_fail;
7578 }
7579 {
7580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7581 }
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj;
7590 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7591 size_t arg2 = (size_t) 0 ;
7592 size_t arg3 = (size_t) 1 ;
7593 bool result;
7594 PyObject * obj0 = 0 ;
7595 PyObject * obj1 = 0 ;
7596 PyObject * obj2 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 if (obj1) {
7605 {
7606 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7607 if (SWIG_arg_fail(2)) SWIG_fail;
7608 }
7609 }
7610 if (obj2) {
7611 {
7612 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7613 if (SWIG_arg_fail(3)) SWIG_fail;
7614 }
7615 }
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj;
7634 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7635 int arg2 ;
7636 wxString result;
7637 PyObject * obj0 = 0 ;
7638 PyObject * obj1 = 0 ;
7639 char *kwnames[] = {
7640 (char *) "self",(char *) "row", NULL
7641 };
7642
7643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7645 if (SWIG_arg_fail(1)) SWIG_fail;
7646 {
7647 arg2 = (int)(SWIG_As_int(obj1));
7648 if (SWIG_arg_fail(2)) SWIG_fail;
7649 }
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (arg1)->GetRowLabelValue(arg2);
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 #if wxUSE_UNICODE
7659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7660 #else
7661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7662 #endif
7663 }
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7673 int arg2 ;
7674 wxString result;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char *kwnames[] = {
7678 (char *) "self",(char *) "col", NULL
7679 };
7680
7681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(1)) SWIG_fail;
7684 {
7685 arg2 = (int)(SWIG_As_int(obj1));
7686 if (SWIG_arg_fail(2)) SWIG_fail;
7687 }
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (arg1)->GetColLabelValue(arg2);
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 #if wxUSE_UNICODE
7697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7698 #else
7699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7700 #endif
7701 }
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj;
7710 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7711 int arg2 ;
7712 wxString *arg3 = 0 ;
7713 bool temp3 = false ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 PyObject * obj2 = 0 ;
7717 char *kwnames[] = {
7718 (char *) "self",(char *) "row",(char *) "value", NULL
7719 };
7720
7721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7723 if (SWIG_arg_fail(1)) SWIG_fail;
7724 {
7725 arg2 = (int)(SWIG_As_int(obj1));
7726 if (SWIG_arg_fail(2)) SWIG_fail;
7727 }
7728 {
7729 arg3 = wxString_in_helper(obj2);
7730 if (arg3 == NULL) SWIG_fail;
7731 temp3 = true;
7732 }
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7736
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 Py_INCREF(Py_None); resultobj = Py_None;
7741 {
7742 if (temp3)
7743 delete arg3;
7744 }
7745 return resultobj;
7746 fail:
7747 {
7748 if (temp3)
7749 delete arg3;
7750 }
7751 return NULL;
7752 }
7753
7754
7755 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7756 PyObject *resultobj;
7757 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7758 int arg2 ;
7759 wxString *arg3 = 0 ;
7760 bool temp3 = false ;
7761 PyObject * obj0 = 0 ;
7762 PyObject * obj1 = 0 ;
7763 PyObject * obj2 = 0 ;
7764 char *kwnames[] = {
7765 (char *) "self",(char *) "col",(char *) "value", NULL
7766 };
7767
7768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7770 if (SWIG_arg_fail(1)) SWIG_fail;
7771 {
7772 arg2 = (int)(SWIG_As_int(obj1));
7773 if (SWIG_arg_fail(2)) SWIG_fail;
7774 }
7775 {
7776 arg3 = wxString_in_helper(obj2);
7777 if (arg3 == NULL) SWIG_fail;
7778 temp3 = true;
7779 }
7780 {
7781 PyThreadState* __tstate = wxPyBeginAllowThreads();
7782 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
7783
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 Py_INCREF(Py_None); resultobj = Py_None;
7788 {
7789 if (temp3)
7790 delete arg3;
7791 }
7792 return resultobj;
7793 fail:
7794 {
7795 if (temp3)
7796 delete arg3;
7797 }
7798 return NULL;
7799 }
7800
7801
7802 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7803 PyObject *resultobj;
7804 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7805 bool result;
7806 PyObject * obj0 = 0 ;
7807 char *kwnames[] = {
7808 (char *) "self", NULL
7809 };
7810
7811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
7812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7813 if (SWIG_arg_fail(1)) SWIG_fail;
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 result = (bool)(arg1)->CanHaveAttributes();
7817
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7831 PyObject *resultobj;
7832 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7833 int arg2 ;
7834 int arg3 ;
7835 wxGridCellAttr::wxAttrKind arg4 ;
7836 wxGridCellAttr *result;
7837 PyObject * obj0 = 0 ;
7838 PyObject * obj1 = 0 ;
7839 PyObject * obj2 = 0 ;
7840 PyObject * obj3 = 0 ;
7841 char *kwnames[] = {
7842 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7843 };
7844
7845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7847 if (SWIG_arg_fail(1)) SWIG_fail;
7848 {
7849 arg2 = (int)(SWIG_As_int(obj1));
7850 if (SWIG_arg_fail(2)) SWIG_fail;
7851 }
7852 {
7853 arg3 = (int)(SWIG_As_int(obj2));
7854 if (SWIG_arg_fail(3)) SWIG_fail;
7855 }
7856 {
7857 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
7858 if (SWIG_arg_fail(4)) SWIG_fail;
7859 }
7860 {
7861 PyThreadState* __tstate = wxPyBeginAllowThreads();
7862 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
7863
7864 wxPyEndAllowThreads(__tstate);
7865 if (PyErr_Occurred()) SWIG_fail;
7866 }
7867 {
7868 resultobj = wxPyMake_wxGridCellAttr(result, 0);
7869 }
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7877 PyObject *resultobj;
7878 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7879 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7880 int arg3 ;
7881 int arg4 ;
7882 PyObject * obj0 = 0 ;
7883 PyObject * obj1 = 0 ;
7884 PyObject * obj2 = 0 ;
7885 PyObject * obj3 = 0 ;
7886 char *kwnames[] = {
7887 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7888 };
7889
7890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7892 if (SWIG_arg_fail(1)) SWIG_fail;
7893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7894 if (SWIG_arg_fail(2)) SWIG_fail;
7895 {
7896 arg3 = (int)(SWIG_As_int(obj2));
7897 if (SWIG_arg_fail(3)) SWIG_fail;
7898 }
7899 {
7900 arg4 = (int)(SWIG_As_int(obj3));
7901 if (SWIG_arg_fail(4)) SWIG_fail;
7902 }
7903 {
7904 PyThreadState* __tstate = wxPyBeginAllowThreads();
7905 (arg1)->SetAttr(arg2,arg3,arg4);
7906
7907 wxPyEndAllowThreads(__tstate);
7908 if (PyErr_Occurred()) SWIG_fail;
7909 }
7910 Py_INCREF(Py_None); resultobj = Py_None;
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj;
7919 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7920 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7921 int arg3 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "self",(char *) "attr",(char *) "row", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(1)) SWIG_fail;
7932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(2)) SWIG_fail;
7934 {
7935 arg3 = (int)(SWIG_As_int(obj2));
7936 if (SWIG_arg_fail(3)) SWIG_fail;
7937 }
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 (arg1)->SetRowAttr(arg2,arg3);
7941
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 Py_INCREF(Py_None); resultobj = Py_None;
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7955 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7956 int arg3 ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 PyObject * obj2 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "self",(char *) "attr",(char *) "col", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(1)) SWIG_fail;
7967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7968 if (SWIG_arg_fail(2)) SWIG_fail;
7969 {
7970 arg3 = (int)(SWIG_As_int(obj2));
7971 if (SWIG_arg_fail(3)) SWIG_fail;
7972 }
7973 {
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 (arg1)->SetColAttr(arg2,arg3);
7976
7977 wxPyEndAllowThreads(__tstate);
7978 if (PyErr_Occurred()) SWIG_fail;
7979 }
7980 Py_INCREF(Py_None); resultobj = Py_None;
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
7988 PyObject *obj;
7989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7990 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
7991 Py_INCREF(obj);
7992 return Py_BuildValue((char *)"");
7993 }
7994 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj;
7996 wxPyGridTableBase *result;
7997 char *kwnames[] = {
7998 NULL
7999 };
8000
8001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8002 {
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8005
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8017 PyObject *resultobj;
8018 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8019 PyObject *arg2 = (PyObject *) 0 ;
8020 PyObject *arg3 = (PyObject *) 0 ;
8021 PyObject * obj0 = 0 ;
8022 PyObject * obj1 = 0 ;
8023 PyObject * obj2 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "self",(char *) "self",(char *) "_class", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8030 if (SWIG_arg_fail(1)) SWIG_fail;
8031 arg2 = obj1;
8032 arg3 = obj2;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 (arg1)->_setCallbackInfo(arg2,arg3);
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 Py_INCREF(Py_None); resultobj = Py_None;
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj;
8049 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8050 PyObject * obj0 = 0 ;
8051 char *kwnames[] = {
8052 (char *) "self", NULL
8053 };
8054
8055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8057 if (SWIG_arg_fail(1)) SWIG_fail;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 wxPyGridTableBase_Destroy(arg1);
8061
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 Py_INCREF(Py_None); resultobj = Py_None;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject *_wrap_PyGridTableBase_base_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj;
8074 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8075 int arg2 ;
8076 int arg3 ;
8077 wxString result;
8078 PyObject * obj0 = 0 ;
8079 PyObject * obj1 = 0 ;
8080 PyObject * obj2 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self",(char *) "row",(char *) "col", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 arg2 = (int)(SWIG_As_int(obj1));
8090 if (SWIG_arg_fail(2)) SWIG_fail;
8091 }
8092 {
8093 arg3 = (int)(SWIG_As_int(obj2));
8094 if (SWIG_arg_fail(3)) SWIG_fail;
8095 }
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (arg1)->base_GetTypeName(arg2,arg3);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 #if wxUSE_UNICODE
8105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8106 #else
8107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8108 #endif
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_PyGridTableBase_base_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8119 int arg2 ;
8120 int arg3 ;
8121 wxString *arg4 = 0 ;
8122 bool result;
8123 bool temp4 = false ;
8124 PyObject * obj0 = 0 ;
8125 PyObject * obj1 = 0 ;
8126 PyObject * obj2 = 0 ;
8127 PyObject * obj3 = 0 ;
8128 char *kwnames[] = {
8129 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8130 };
8131
8132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8134 if (SWIG_arg_fail(1)) SWIG_fail;
8135 {
8136 arg2 = (int)(SWIG_As_int(obj1));
8137 if (SWIG_arg_fail(2)) SWIG_fail;
8138 }
8139 {
8140 arg3 = (int)(SWIG_As_int(obj2));
8141 if (SWIG_arg_fail(3)) SWIG_fail;
8142 }
8143 {
8144 arg4 = wxString_in_helper(obj3);
8145 if (arg4 == NULL) SWIG_fail;
8146 temp4 = true;
8147 }
8148 {
8149 PyThreadState* __tstate = wxPyBeginAllowThreads();
8150 result = (bool)(arg1)->base_CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8151
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 {
8156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8157 }
8158 {
8159 if (temp4)
8160 delete arg4;
8161 }
8162 return resultobj;
8163 fail:
8164 {
8165 if (temp4)
8166 delete arg4;
8167 }
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_PyGridTableBase_base_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8175 int arg2 ;
8176 int arg3 ;
8177 wxString *arg4 = 0 ;
8178 bool result;
8179 bool temp4 = false ;
8180 PyObject * obj0 = 0 ;
8181 PyObject * obj1 = 0 ;
8182 PyObject * obj2 = 0 ;
8183 PyObject * obj3 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 {
8192 arg2 = (int)(SWIG_As_int(obj1));
8193 if (SWIG_arg_fail(2)) SWIG_fail;
8194 }
8195 {
8196 arg3 = (int)(SWIG_As_int(obj2));
8197 if (SWIG_arg_fail(3)) SWIG_fail;
8198 }
8199 {
8200 arg4 = wxString_in_helper(obj3);
8201 if (arg4 == NULL) SWIG_fail;
8202 temp4 = true;
8203 }
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 result = (bool)(arg1)->base_CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8213 }
8214 {
8215 if (temp4)
8216 delete arg4;
8217 }
8218 return resultobj;
8219 fail:
8220 {
8221 if (temp4)
8222 delete arg4;
8223 }
8224 return NULL;
8225 }
8226
8227
8228 static PyObject *_wrap_PyGridTableBase_base_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj;
8230 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8231 PyObject * obj0 = 0 ;
8232 char *kwnames[] = {
8233 (char *) "self", NULL
8234 };
8235
8236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_Clear",kwnames,&obj0)) goto fail;
8237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8238 if (SWIG_arg_fail(1)) SWIG_fail;
8239 {
8240 PyThreadState* __tstate = wxPyBeginAllowThreads();
8241 (arg1)->base_Clear();
8242
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 Py_INCREF(Py_None); resultobj = Py_None;
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 static PyObject *_wrap_PyGridTableBase_base_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj;
8255 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8256 size_t arg2 = (size_t) 0 ;
8257 size_t arg3 = (size_t) 1 ;
8258 bool result;
8259 PyObject * obj0 = 0 ;
8260 PyObject * obj1 = 0 ;
8261 PyObject * obj2 = 0 ;
8262 char *kwnames[] = {
8263 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8264 };
8265
8266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8268 if (SWIG_arg_fail(1)) SWIG_fail;
8269 if (obj1) {
8270 {
8271 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8272 if (SWIG_arg_fail(2)) SWIG_fail;
8273 }
8274 }
8275 if (obj2) {
8276 {
8277 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8278 if (SWIG_arg_fail(3)) SWIG_fail;
8279 }
8280 }
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (bool)(arg1)->base_InsertRows(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8290 }
8291 return resultobj;
8292 fail:
8293 return NULL;
8294 }
8295
8296
8297 static PyObject *_wrap_PyGridTableBase_base_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj;
8299 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8300 size_t arg2 = (size_t) 1 ;
8301 bool result;
8302 PyObject * obj0 = 0 ;
8303 PyObject * obj1 = 0 ;
8304 char *kwnames[] = {
8305 (char *) "self",(char *) "numRows", NULL
8306 };
8307
8308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8310 if (SWIG_arg_fail(1)) SWIG_fail;
8311 if (obj1) {
8312 {
8313 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8314 if (SWIG_arg_fail(2)) SWIG_fail;
8315 }
8316 }
8317 {
8318 PyThreadState* __tstate = wxPyBeginAllowThreads();
8319 result = (bool)(arg1)->base_AppendRows(arg2);
8320
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 {
8325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8326 }
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 static PyObject *_wrap_PyGridTableBase_base_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8334 PyObject *resultobj;
8335 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8336 size_t arg2 = (size_t) 0 ;
8337 size_t arg3 = (size_t) 1 ;
8338 bool result;
8339 PyObject * obj0 = 0 ;
8340 PyObject * obj1 = 0 ;
8341 PyObject * obj2 = 0 ;
8342 char *kwnames[] = {
8343 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8344 };
8345
8346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8348 if (SWIG_arg_fail(1)) SWIG_fail;
8349 if (obj1) {
8350 {
8351 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8352 if (SWIG_arg_fail(2)) SWIG_fail;
8353 }
8354 }
8355 if (obj2) {
8356 {
8357 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8358 if (SWIG_arg_fail(3)) SWIG_fail;
8359 }
8360 }
8361 {
8362 PyThreadState* __tstate = wxPyBeginAllowThreads();
8363 result = (bool)(arg1)->base_DeleteRows(arg2,arg3);
8364
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 {
8369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8370 }
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 static PyObject *_wrap_PyGridTableBase_base_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj;
8379 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8380 size_t arg2 = (size_t) 0 ;
8381 size_t arg3 = (size_t) 1 ;
8382 bool result;
8383 PyObject * obj0 = 0 ;
8384 PyObject * obj1 = 0 ;
8385 PyObject * obj2 = 0 ;
8386 char *kwnames[] = {
8387 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8388 };
8389
8390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8392 if (SWIG_arg_fail(1)) SWIG_fail;
8393 if (obj1) {
8394 {
8395 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8396 if (SWIG_arg_fail(2)) SWIG_fail;
8397 }
8398 }
8399 if (obj2) {
8400 {
8401 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8402 if (SWIG_arg_fail(3)) SWIG_fail;
8403 }
8404 }
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (bool)(arg1)->base_InsertCols(arg2,arg3);
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8414 }
8415 return resultobj;
8416 fail:
8417 return NULL;
8418 }
8419
8420
8421 static PyObject *_wrap_PyGridTableBase_base_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj;
8423 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8424 size_t arg2 = (size_t) 1 ;
8425 bool result;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 char *kwnames[] = {
8429 (char *) "self",(char *) "numCols", NULL
8430 };
8431
8432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8434 if (SWIG_arg_fail(1)) SWIG_fail;
8435 if (obj1) {
8436 {
8437 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8438 if (SWIG_arg_fail(2)) SWIG_fail;
8439 }
8440 }
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (bool)(arg1)->base_AppendCols(arg2);
8444
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 {
8449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8450 }
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 static PyObject *_wrap_PyGridTableBase_base_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj;
8459 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8460 size_t arg2 = (size_t) 0 ;
8461 size_t arg3 = (size_t) 1 ;
8462 bool result;
8463 PyObject * obj0 = 0 ;
8464 PyObject * obj1 = 0 ;
8465 PyObject * obj2 = 0 ;
8466 char *kwnames[] = {
8467 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8468 };
8469
8470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8472 if (SWIG_arg_fail(1)) SWIG_fail;
8473 if (obj1) {
8474 {
8475 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8476 if (SWIG_arg_fail(2)) SWIG_fail;
8477 }
8478 }
8479 if (obj2) {
8480 {
8481 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8482 if (SWIG_arg_fail(3)) SWIG_fail;
8483 }
8484 }
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (bool)(arg1)->base_DeleteCols(arg2,arg3);
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8494 }
8495 return resultobj;
8496 fail:
8497 return NULL;
8498 }
8499
8500
8501 static PyObject *_wrap_PyGridTableBase_base_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8502 PyObject *resultobj;
8503 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8504 int arg2 ;
8505 wxString result;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char *kwnames[] = {
8509 (char *) "self",(char *) "row", NULL
8510 };
8511
8512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8514 if (SWIG_arg_fail(1)) SWIG_fail;
8515 {
8516 arg2 = (int)(SWIG_As_int(obj1));
8517 if (SWIG_arg_fail(2)) SWIG_fail;
8518 }
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 result = (arg1)->base_GetRowLabelValue(arg2);
8522
8523 wxPyEndAllowThreads(__tstate);
8524 if (PyErr_Occurred()) SWIG_fail;
8525 }
8526 {
8527 #if wxUSE_UNICODE
8528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8529 #else
8530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8531 #endif
8532 }
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject *_wrap_PyGridTableBase_base_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj;
8541 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8542 int arg2 ;
8543 wxString result;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self",(char *) "col", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 arg2 = (int)(SWIG_As_int(obj1));
8555 if (SWIG_arg_fail(2)) SWIG_fail;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 result = (arg1)->base_GetColLabelValue(arg2);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 {
8565 #if wxUSE_UNICODE
8566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8567 #else
8568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8569 #endif
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_PyGridTableBase_base_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8580 int arg2 ;
8581 wxString *arg3 = 0 ;
8582 bool temp3 = false ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 PyObject * obj2 = 0 ;
8586 char *kwnames[] = {
8587 (char *) "self",(char *) "row",(char *) "value", NULL
8588 };
8589
8590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 {
8594 arg2 = (int)(SWIG_As_int(obj1));
8595 if (SWIG_arg_fail(2)) SWIG_fail;
8596 }
8597 {
8598 arg3 = wxString_in_helper(obj2);
8599 if (arg3 == NULL) SWIG_fail;
8600 temp3 = true;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 (arg1)->base_SetRowLabelValue(arg2,(wxString const &)*arg3);
8605
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 Py_INCREF(Py_None); resultobj = Py_None;
8610 {
8611 if (temp3)
8612 delete arg3;
8613 }
8614 return resultobj;
8615 fail:
8616 {
8617 if (temp3)
8618 delete arg3;
8619 }
8620 return NULL;
8621 }
8622
8623
8624 static PyObject *_wrap_PyGridTableBase_base_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj;
8626 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8627 int arg2 ;
8628 wxString *arg3 = 0 ;
8629 bool temp3 = false ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 PyObject * obj2 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "col",(char *) "value", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = (int)(SWIG_As_int(obj1));
8642 if (SWIG_arg_fail(2)) SWIG_fail;
8643 }
8644 {
8645 arg3 = wxString_in_helper(obj2);
8646 if (arg3 == NULL) SWIG_fail;
8647 temp3 = true;
8648 }
8649 {
8650 PyThreadState* __tstate = wxPyBeginAllowThreads();
8651 (arg1)->base_SetColLabelValue(arg2,(wxString const &)*arg3);
8652
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 Py_INCREF(Py_None); resultobj = Py_None;
8657 {
8658 if (temp3)
8659 delete arg3;
8660 }
8661 return resultobj;
8662 fail:
8663 {
8664 if (temp3)
8665 delete arg3;
8666 }
8667 return NULL;
8668 }
8669
8670
8671 static PyObject *_wrap_PyGridTableBase_base_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj;
8673 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8674 bool result;
8675 PyObject * obj0 = 0 ;
8676 char *kwnames[] = {
8677 (char *) "self", NULL
8678 };
8679
8680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_CanHaveAttributes",kwnames,&obj0)) goto fail;
8681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 {
8684 PyThreadState* __tstate = wxPyBeginAllowThreads();
8685 result = (bool)(arg1)->base_CanHaveAttributes();
8686
8687 wxPyEndAllowThreads(__tstate);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 {
8691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8692 }
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_PyGridTableBase_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8702 int arg2 ;
8703 int arg3 ;
8704 wxGridCellAttr::wxAttrKind arg4 ;
8705 wxGridCellAttr *result;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 PyObject * obj2 = 0 ;
8709 PyObject * obj3 = 0 ;
8710 char *kwnames[] = {
8711 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8712 };
8713
8714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8716 if (SWIG_arg_fail(1)) SWIG_fail;
8717 {
8718 arg2 = (int)(SWIG_As_int(obj1));
8719 if (SWIG_arg_fail(2)) SWIG_fail;
8720 }
8721 {
8722 arg3 = (int)(SWIG_As_int(obj2));
8723 if (SWIG_arg_fail(3)) SWIG_fail;
8724 }
8725 {
8726 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
8727 if (SWIG_arg_fail(4)) SWIG_fail;
8728 }
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 {
8737 resultobj = wxPyMake_wxGridCellAttr(result, 0);
8738 }
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_PyGridTableBase_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj;
8747 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8748 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8749 int arg3 ;
8750 int arg4 ;
8751 PyObject * obj0 = 0 ;
8752 PyObject * obj1 = 0 ;
8753 PyObject * obj2 = 0 ;
8754 PyObject * obj3 = 0 ;
8755 char *kwnames[] = {
8756 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8757 };
8758
8759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8761 if (SWIG_arg_fail(1)) SWIG_fail;
8762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8763 if (SWIG_arg_fail(2)) SWIG_fail;
8764 {
8765 arg3 = (int)(SWIG_As_int(obj2));
8766 if (SWIG_arg_fail(3)) SWIG_fail;
8767 }
8768 {
8769 arg4 = (int)(SWIG_As_int(obj3));
8770 if (SWIG_arg_fail(4)) SWIG_fail;
8771 }
8772 {
8773 PyThreadState* __tstate = wxPyBeginAllowThreads();
8774 (arg1)->base_SetAttr(arg2,arg3,arg4);
8775
8776 wxPyEndAllowThreads(__tstate);
8777 if (PyErr_Occurred()) SWIG_fail;
8778 }
8779 Py_INCREF(Py_None); resultobj = Py_None;
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_PyGridTableBase_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj;
8788 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8789 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8790 int arg3 ;
8791 PyObject * obj0 = 0 ;
8792 PyObject * obj1 = 0 ;
8793 PyObject * obj2 = 0 ;
8794 char *kwnames[] = {
8795 (char *) "self",(char *) "attr",(char *) "row", NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8800 if (SWIG_arg_fail(1)) SWIG_fail;
8801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8802 if (SWIG_arg_fail(2)) SWIG_fail;
8803 {
8804 arg3 = (int)(SWIG_As_int(obj2));
8805 if (SWIG_arg_fail(3)) SWIG_fail;
8806 }
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 (arg1)->base_SetRowAttr(arg2,arg3);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 Py_INCREF(Py_None); resultobj = Py_None;
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 static PyObject *_wrap_PyGridTableBase_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8822 PyObject *resultobj;
8823 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8824 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8825 int arg3 ;
8826 PyObject * obj0 = 0 ;
8827 PyObject * obj1 = 0 ;
8828 PyObject * obj2 = 0 ;
8829 char *kwnames[] = {
8830 (char *) "self",(char *) "attr",(char *) "col", NULL
8831 };
8832
8833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8835 if (SWIG_arg_fail(1)) SWIG_fail;
8836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(2)) SWIG_fail;
8838 {
8839 arg3 = (int)(SWIG_As_int(obj2));
8840 if (SWIG_arg_fail(3)) SWIG_fail;
8841 }
8842 {
8843 PyThreadState* __tstate = wxPyBeginAllowThreads();
8844 (arg1)->base_SetColAttr(arg2,arg3);
8845
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 Py_INCREF(Py_None); resultobj = Py_None;
8850 return resultobj;
8851 fail:
8852 return NULL;
8853 }
8854
8855
8856 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
8857 PyObject *obj;
8858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8859 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
8860 Py_INCREF(obj);
8861 return Py_BuildValue((char *)"");
8862 }
8863 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
8864 PyObject *resultobj;
8865 int arg1 = (int) 0 ;
8866 int arg2 = (int) 0 ;
8867 wxGridStringTable *result;
8868 PyObject * obj0 = 0 ;
8869 PyObject * obj1 = 0 ;
8870 char *kwnames[] = {
8871 (char *) "numRows",(char *) "numCols", NULL
8872 };
8873
8874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
8875 if (obj0) {
8876 {
8877 arg1 = (int)(SWIG_As_int(obj0));
8878 if (SWIG_arg_fail(1)) SWIG_fail;
8879 }
8880 }
8881 if (obj1) {
8882 {
8883 arg2 = (int)(SWIG_As_int(obj1));
8884 if (SWIG_arg_fail(2)) SWIG_fail;
8885 }
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
8895 return resultobj;
8896 fail:
8897 return NULL;
8898 }
8899
8900
8901 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
8902 PyObject *obj;
8903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8904 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
8905 Py_INCREF(obj);
8906 return Py_BuildValue((char *)"");
8907 }
8908 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj;
8910 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8911 int arg2 ;
8912 int arg3 = (int) -1 ;
8913 int arg4 = (int) -1 ;
8914 wxGridTableMessage *result;
8915 PyObject * obj0 = 0 ;
8916 PyObject * obj1 = 0 ;
8917 PyObject * obj2 = 0 ;
8918 PyObject * obj3 = 0 ;
8919 char *kwnames[] = {
8920 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
8921 };
8922
8923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8925 if (SWIG_arg_fail(1)) SWIG_fail;
8926 {
8927 arg2 = (int)(SWIG_As_int(obj1));
8928 if (SWIG_arg_fail(2)) SWIG_fail;
8929 }
8930 if (obj2) {
8931 {
8932 arg3 = (int)(SWIG_As_int(obj2));
8933 if (SWIG_arg_fail(3)) SWIG_fail;
8934 }
8935 }
8936 if (obj3) {
8937 {
8938 arg4 = (int)(SWIG_As_int(obj3));
8939 if (SWIG_arg_fail(4)) SWIG_fail;
8940 }
8941 }
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8959 PyObject * obj0 = 0 ;
8960 char *kwnames[] = {
8961 (char *) "self", NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
8965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 delete arg1;
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 Py_INCREF(Py_None); resultobj = Py_None;
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8984 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "self",(char *) "table", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
8992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8993 if (SWIG_arg_fail(1)) SWIG_fail;
8994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(2)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 (arg1)->SetTableObject(arg2);
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 Py_INCREF(Py_None); resultobj = Py_None;
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9011 PyObject *resultobj;
9012 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9013 wxGridTableBase *result;
9014 PyObject * obj0 = 0 ;
9015 char *kwnames[] = {
9016 (char *) "self", NULL
9017 };
9018
9019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9021 if (SWIG_arg_fail(1)) SWIG_fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 {
9030 resultobj = wxPyMake_wxGridTableBase(result, 0);
9031 }
9032 return resultobj;
9033 fail:
9034 return NULL;
9035 }
9036
9037
9038 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj;
9040 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9041 int arg2 ;
9042 PyObject * obj0 = 0 ;
9043 PyObject * obj1 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "self",(char *) "id", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9050 if (SWIG_arg_fail(1)) SWIG_fail;
9051 {
9052 arg2 = (int)(SWIG_As_int(obj1));
9053 if (SWIG_arg_fail(2)) SWIG_fail;
9054 }
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 (arg1)->SetId(arg2);
9058
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 Py_INCREF(Py_None); resultobj = Py_None;
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj;
9071 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9072 int result;
9073 PyObject * obj0 = 0 ;
9074 char *kwnames[] = {
9075 (char *) "self", NULL
9076 };
9077
9078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9080 if (SWIG_arg_fail(1)) SWIG_fail;
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 result = (int)(arg1)->GetId();
9084
9085 wxPyEndAllowThreads(__tstate);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 {
9089 resultobj = SWIG_From_int((int)(result));
9090 }
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj;
9099 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9100 int arg2 ;
9101 PyObject * obj0 = 0 ;
9102 PyObject * obj1 = 0 ;
9103 char *kwnames[] = {
9104 (char *) "self",(char *) "comInt1", NULL
9105 };
9106
9107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9109 if (SWIG_arg_fail(1)) SWIG_fail;
9110 {
9111 arg2 = (int)(SWIG_As_int(obj1));
9112 if (SWIG_arg_fail(2)) SWIG_fail;
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 (arg1)->SetCommandInt(arg2);
9117
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 Py_INCREF(Py_None); resultobj = Py_None;
9122 return resultobj;
9123 fail:
9124 return NULL;
9125 }
9126
9127
9128 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj;
9130 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9131 int result;
9132 PyObject * obj0 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "self", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9139 if (SWIG_arg_fail(1)) SWIG_fail;
9140 {
9141 PyThreadState* __tstate = wxPyBeginAllowThreads();
9142 result = (int)(arg1)->GetCommandInt();
9143
9144 wxPyEndAllowThreads(__tstate);
9145 if (PyErr_Occurred()) SWIG_fail;
9146 }
9147 {
9148 resultobj = SWIG_From_int((int)(result));
9149 }
9150 return resultobj;
9151 fail:
9152 return NULL;
9153 }
9154
9155
9156 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9157 PyObject *resultobj;
9158 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9159 int arg2 ;
9160 PyObject * obj0 = 0 ;
9161 PyObject * obj1 = 0 ;
9162 char *kwnames[] = {
9163 (char *) "self",(char *) "comInt2", NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 {
9170 arg2 = (int)(SWIG_As_int(obj1));
9171 if (SWIG_arg_fail(2)) SWIG_fail;
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 (arg1)->SetCommandInt2(arg2);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 Py_INCREF(Py_None); resultobj = Py_None;
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj;
9189 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9190 int result;
9191 PyObject * obj0 = 0 ;
9192 char *kwnames[] = {
9193 (char *) "self", NULL
9194 };
9195
9196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9198 if (SWIG_arg_fail(1)) SWIG_fail;
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (int)(arg1)->GetCommandInt2();
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = SWIG_From_int((int)(result));
9208 }
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9216 PyObject *obj;
9217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9218 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9219 Py_INCREF(obj);
9220 return Py_BuildValue((char *)"");
9221 }
9222 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9223 PyObject *resultobj;
9224 int arg1 = (int) -1 ;
9225 int arg2 = (int) -1 ;
9226 wxGridCellCoords *result;
9227 PyObject * obj0 = 0 ;
9228 PyObject * obj1 = 0 ;
9229 char *kwnames[] = {
9230 (char *) "r",(char *) "c", NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9234 if (obj0) {
9235 {
9236 arg1 = (int)(SWIG_As_int(obj0));
9237 if (SWIG_arg_fail(1)) SWIG_fail;
9238 }
9239 }
9240 if (obj1) {
9241 {
9242 arg2 = (int)(SWIG_As_int(obj1));
9243 if (SWIG_arg_fail(2)) SWIG_fail;
9244 }
9245 }
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "self", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9270 if (SWIG_arg_fail(1)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 delete arg1;
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 Py_INCREF(Py_None); resultobj = Py_None;
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj;
9287 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9288 int result;
9289 PyObject * obj0 = 0 ;
9290 char *kwnames[] = {
9291 (char *) "self", NULL
9292 };
9293
9294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(1)) SWIG_fail;
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9300
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 {
9305 resultobj = SWIG_From_int((int)(result));
9306 }
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj;
9315 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9316 int arg2 ;
9317 PyObject * obj0 = 0 ;
9318 PyObject * obj1 = 0 ;
9319 char *kwnames[] = {
9320 (char *) "self",(char *) "n", NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9325 if (SWIG_arg_fail(1)) SWIG_fail;
9326 {
9327 arg2 = (int)(SWIG_As_int(obj1));
9328 if (SWIG_arg_fail(2)) SWIG_fail;
9329 }
9330 {
9331 PyThreadState* __tstate = wxPyBeginAllowThreads();
9332 (arg1)->SetRow(arg2);
9333
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 Py_INCREF(Py_None); resultobj = Py_None;
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9345 PyObject *resultobj;
9346 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9347 int result;
9348 PyObject * obj0 = 0 ;
9349 char *kwnames[] = {
9350 (char *) "self", NULL
9351 };
9352
9353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9355 if (SWIG_arg_fail(1)) SWIG_fail;
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9359
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 {
9364 resultobj = SWIG_From_int((int)(result));
9365 }
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj;
9374 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9375 int arg2 ;
9376 PyObject * obj0 = 0 ;
9377 PyObject * obj1 = 0 ;
9378 char *kwnames[] = {
9379 (char *) "self",(char *) "n", NULL
9380 };
9381
9382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9384 if (SWIG_arg_fail(1)) SWIG_fail;
9385 {
9386 arg2 = (int)(SWIG_As_int(obj1));
9387 if (SWIG_arg_fail(2)) SWIG_fail;
9388 }
9389 {
9390 PyThreadState* __tstate = wxPyBeginAllowThreads();
9391 (arg1)->SetCol(arg2);
9392
9393 wxPyEndAllowThreads(__tstate);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 Py_INCREF(Py_None); resultobj = Py_None;
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9404 PyObject *resultobj;
9405 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9406 int arg2 ;
9407 int arg3 ;
9408 PyObject * obj0 = 0 ;
9409 PyObject * obj1 = 0 ;
9410 PyObject * obj2 = 0 ;
9411 char *kwnames[] = {
9412 (char *) "self",(char *) "row",(char *) "col", NULL
9413 };
9414
9415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9417 if (SWIG_arg_fail(1)) SWIG_fail;
9418 {
9419 arg2 = (int)(SWIG_As_int(obj1));
9420 if (SWIG_arg_fail(2)) SWIG_fail;
9421 }
9422 {
9423 arg3 = (int)(SWIG_As_int(obj2));
9424 if (SWIG_arg_fail(3)) SWIG_fail;
9425 }
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 (arg1)->Set(arg2,arg3);
9429
9430 wxPyEndAllowThreads(__tstate);
9431 if (PyErr_Occurred()) SWIG_fail;
9432 }
9433 Py_INCREF(Py_None); resultobj = Py_None;
9434 return resultobj;
9435 fail:
9436 return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj;
9442 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9443 wxGridCellCoords *arg2 = 0 ;
9444 bool result;
9445 wxGridCellCoords temp2 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char *kwnames[] = {
9449 (char *) "self",(char *) "other", NULL
9450 };
9451
9452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) goto fail;
9453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9454 if (SWIG_arg_fail(1)) SWIG_fail;
9455 {
9456 arg2 = &temp2;
9457 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9458 }
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9462
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 {
9467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9468 }
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9476 PyObject *resultobj;
9477 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9478 wxGridCellCoords *arg2 = 0 ;
9479 bool result;
9480 wxGridCellCoords temp2 ;
9481 PyObject * obj0 = 0 ;
9482 PyObject * obj1 = 0 ;
9483 char *kwnames[] = {
9484 (char *) "self",(char *) "other", NULL
9485 };
9486
9487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9489 if (SWIG_arg_fail(1)) SWIG_fail;
9490 {
9491 arg2 = &temp2;
9492 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9493 }
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9497
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 {
9502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9503 }
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj;
9512 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9513 PyObject *result;
9514 PyObject * obj0 = 0 ;
9515 char *kwnames[] = {
9516 (char *) "self", NULL
9517 };
9518
9519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9521 if (SWIG_arg_fail(1)) SWIG_fail;
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (PyObject *)wxGridCellCoords_Get(arg1);
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = result;
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9537 PyObject *obj;
9538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9539 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9540 Py_INCREF(obj);
9541 return Py_BuildValue((char *)"");
9542 }
9543 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxWindow *arg1 = (wxWindow *) 0 ;
9546 int arg2 = (int) -1 ;
9547 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9548 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9549 wxSize const &arg4_defvalue = wxDefaultSize ;
9550 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9551 long arg5 = (long) wxWANTS_CHARS ;
9552 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9553 wxString *arg6 = (wxString *) &arg6_defvalue ;
9554 wxGrid *result;
9555 wxPoint temp3 ;
9556 wxSize temp4 ;
9557 bool temp6 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 PyObject * obj3 = 0 ;
9562 PyObject * obj4 = 0 ;
9563 PyObject * obj5 = 0 ;
9564 char *kwnames[] = {
9565 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9566 };
9567
9568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9570 if (SWIG_arg_fail(1)) SWIG_fail;
9571 if (obj1) {
9572 {
9573 arg2 = (int)(SWIG_As_int(obj1));
9574 if (SWIG_arg_fail(2)) SWIG_fail;
9575 }
9576 }
9577 if (obj2) {
9578 {
9579 arg3 = &temp3;
9580 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9581 }
9582 }
9583 if (obj3) {
9584 {
9585 arg4 = &temp4;
9586 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9587 }
9588 }
9589 if (obj4) {
9590 {
9591 arg5 = (long)(SWIG_As_long(obj4));
9592 if (SWIG_arg_fail(5)) SWIG_fail;
9593 }
9594 }
9595 if (obj5) {
9596 {
9597 arg6 = wxString_in_helper(obj5);
9598 if (arg6 == NULL) SWIG_fail;
9599 temp6 = true;
9600 }
9601 }
9602 {
9603 if (!wxPyCheckForApp()) SWIG_fail;
9604 PyThreadState* __tstate = wxPyBeginAllowThreads();
9605 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9606
9607 wxPyEndAllowThreads(__tstate);
9608 if (PyErr_Occurred()) SWIG_fail;
9609 }
9610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9611 {
9612 if (temp6)
9613 delete arg6;
9614 }
9615 return resultobj;
9616 fail:
9617 {
9618 if (temp6)
9619 delete arg6;
9620 }
9621 return NULL;
9622 }
9623
9624
9625 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxGrid *result;
9628 char *kwnames[] = {
9629 NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9633 {
9634 if (!wxPyCheckForApp()) SWIG_fail;
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 result = (wxGrid *)new wxGrid();
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj;
9650 wxGrid *arg1 = (wxGrid *) 0 ;
9651 wxWindow *arg2 = (wxWindow *) 0 ;
9652 int arg3 = (int) -1 ;
9653 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9654 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9655 wxSize const &arg5_defvalue = wxDefaultSize ;
9656 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9657 long arg6 = (long) wxWANTS_CHARS ;
9658 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9659 wxString *arg7 = (wxString *) &arg7_defvalue ;
9660 bool result;
9661 wxPoint temp4 ;
9662 wxSize temp5 ;
9663 bool temp7 = false ;
9664 PyObject * obj0 = 0 ;
9665 PyObject * obj1 = 0 ;
9666 PyObject * obj2 = 0 ;
9667 PyObject * obj3 = 0 ;
9668 PyObject * obj4 = 0 ;
9669 PyObject * obj5 = 0 ;
9670 PyObject * obj6 = 0 ;
9671 char *kwnames[] = {
9672 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9673 };
9674
9675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9677 if (SWIG_arg_fail(1)) SWIG_fail;
9678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9679 if (SWIG_arg_fail(2)) SWIG_fail;
9680 if (obj2) {
9681 {
9682 arg3 = (int)(SWIG_As_int(obj2));
9683 if (SWIG_arg_fail(3)) SWIG_fail;
9684 }
9685 }
9686 if (obj3) {
9687 {
9688 arg4 = &temp4;
9689 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9690 }
9691 }
9692 if (obj4) {
9693 {
9694 arg5 = &temp5;
9695 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9696 }
9697 }
9698 if (obj5) {
9699 {
9700 arg6 = (long)(SWIG_As_long(obj5));
9701 if (SWIG_arg_fail(6)) SWIG_fail;
9702 }
9703 }
9704 if (obj6) {
9705 {
9706 arg7 = wxString_in_helper(obj6);
9707 if (arg7 == NULL) SWIG_fail;
9708 temp7 = true;
9709 }
9710 }
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9714
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 {
9719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9720 }
9721 {
9722 if (temp7)
9723 delete arg7;
9724 }
9725 return resultobj;
9726 fail:
9727 {
9728 if (temp7)
9729 delete arg7;
9730 }
9731 return NULL;
9732 }
9733
9734
9735 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj;
9737 wxGrid *arg1 = (wxGrid *) 0 ;
9738 int arg2 ;
9739 int arg3 ;
9740 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9741 bool result;
9742 PyObject * obj0 = 0 ;
9743 PyObject * obj1 = 0 ;
9744 PyObject * obj2 = 0 ;
9745 PyObject * obj3 = 0 ;
9746 char *kwnames[] = {
9747 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9748 };
9749
9750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9752 if (SWIG_arg_fail(1)) SWIG_fail;
9753 {
9754 arg2 = (int)(SWIG_As_int(obj1));
9755 if (SWIG_arg_fail(2)) SWIG_fail;
9756 }
9757 {
9758 arg3 = (int)(SWIG_As_int(obj2));
9759 if (SWIG_arg_fail(3)) SWIG_fail;
9760 }
9761 if (obj3) {
9762 {
9763 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9764 if (SWIG_arg_fail(4)) SWIG_fail;
9765 }
9766 }
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9776 }
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxGrid *arg1 = (wxGrid *) 0 ;
9786 WXGRIDSELECTIONMODES arg2 ;
9787 PyObject * obj0 = 0 ;
9788 PyObject * obj1 = 0 ;
9789 char *kwnames[] = {
9790 (char *) "self",(char *) "selmode", NULL
9791 };
9792
9793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
9794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9795 if (SWIG_arg_fail(1)) SWIG_fail;
9796 {
9797 arg2 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj1));
9798 if (SWIG_arg_fail(2)) SWIG_fail;
9799 }
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 (arg1)->SetSelectionMode(arg2);
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 Py_INCREF(Py_None); resultobj = Py_None;
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj;
9816 wxGrid *arg1 = (wxGrid *) 0 ;
9817 WXGRIDSELECTIONMODES result;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "self", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 resultobj = SWIG_From_int((int)(result));
9835 }
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj;
9844 wxGrid *arg1 = (wxGrid *) 0 ;
9845 int result;
9846 PyObject * obj0 = 0 ;
9847 char *kwnames[] = {
9848 (char *) "self", NULL
9849 };
9850
9851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
9852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9853 if (SWIG_arg_fail(1)) SWIG_fail;
9854 {
9855 PyThreadState* __tstate = wxPyBeginAllowThreads();
9856 result = (int)(arg1)->GetNumberRows();
9857
9858 wxPyEndAllowThreads(__tstate);
9859 if (PyErr_Occurred()) SWIG_fail;
9860 }
9861 {
9862 resultobj = SWIG_From_int((int)(result));
9863 }
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj;
9872 wxGrid *arg1 = (wxGrid *) 0 ;
9873 int result;
9874 PyObject * obj0 = 0 ;
9875 char *kwnames[] = {
9876 (char *) "self", NULL
9877 };
9878
9879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
9880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9881 if (SWIG_arg_fail(1)) SWIG_fail;
9882 {
9883 PyThreadState* __tstate = wxPyBeginAllowThreads();
9884 result = (int)(arg1)->GetNumberCols();
9885
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 resultobj = SWIG_From_int((int)(result));
9891 }
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxGrid *arg1 = (wxGrid *) 0 ;
9901 wxGridTableMessage *arg2 = 0 ;
9902 bool result;
9903 PyObject * obj0 = 0 ;
9904 PyObject * obj1 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self","arg2", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(2)) SWIG_fail;
9915 if (arg2 == NULL) {
9916 SWIG_null_ref("wxGridTableMessage");
9917 }
9918 if (SWIG_arg_fail(2)) SWIG_fail;
9919 }
9920 {
9921 PyThreadState* __tstate = wxPyBeginAllowThreads();
9922 result = (bool)(arg1)->ProcessTableMessage(*arg2);
9923
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 {
9928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9929 }
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj;
9938 wxGrid *arg1 = (wxGrid *) 0 ;
9939 wxGridTableBase *result;
9940 PyObject * obj0 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "self", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
9946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9947 if (SWIG_arg_fail(1)) SWIG_fail;
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
9951
9952 wxPyEndAllowThreads(__tstate);
9953 if (PyErr_Occurred()) SWIG_fail;
9954 }
9955 {
9956 resultobj = wxPyMake_wxGridTableBase(result, 0);
9957 }
9958 return resultobj;
9959 fail:
9960 return NULL;
9961 }
9962
9963
9964 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9965 PyObject *resultobj;
9966 wxGrid *arg1 = (wxGrid *) 0 ;
9967 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9968 bool arg3 = (bool) false ;
9969 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9970 bool result;
9971 PyObject * obj0 = 0 ;
9972 PyObject * obj1 = 0 ;
9973 PyObject * obj2 = 0 ;
9974 PyObject * obj3 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9981 if (SWIG_arg_fail(1)) SWIG_fail;
9982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9983 if (SWIG_arg_fail(2)) SWIG_fail;
9984 if (obj2) {
9985 {
9986 arg3 = (bool)(SWIG_As_bool(obj2));
9987 if (SWIG_arg_fail(3)) SWIG_fail;
9988 }
9989 }
9990 if (obj3) {
9991 {
9992 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9993 if (SWIG_arg_fail(4)) SWIG_fail;
9994 }
9995 }
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
9999
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 {
10004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10005 }
10006 return resultobj;
10007 fail:
10008 return NULL;
10009 }
10010
10011
10012 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj;
10014 wxGrid *arg1 = (wxGrid *) 0 ;
10015 PyObject * obj0 = 0 ;
10016 char *kwnames[] = {
10017 (char *) "self", NULL
10018 };
10019
10020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10022 if (SWIG_arg_fail(1)) SWIG_fail;
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 (arg1)->ClearGrid();
10026
10027 wxPyEndAllowThreads(__tstate);
10028 if (PyErr_Occurred()) SWIG_fail;
10029 }
10030 Py_INCREF(Py_None); resultobj = Py_None;
10031 return resultobj;
10032 fail:
10033 return NULL;
10034 }
10035
10036
10037 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 wxGrid *arg1 = (wxGrid *) 0 ;
10040 int arg2 = (int) 0 ;
10041 int arg3 = (int) 1 ;
10042 bool arg4 = (bool) true ;
10043 bool result;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 PyObject * obj2 = 0 ;
10047 PyObject * obj3 = 0 ;
10048 char *kwnames[] = {
10049 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10050 };
10051
10052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10054 if (SWIG_arg_fail(1)) SWIG_fail;
10055 if (obj1) {
10056 {
10057 arg2 = (int)(SWIG_As_int(obj1));
10058 if (SWIG_arg_fail(2)) SWIG_fail;
10059 }
10060 }
10061 if (obj2) {
10062 {
10063 arg3 = (int)(SWIG_As_int(obj2));
10064 if (SWIG_arg_fail(3)) SWIG_fail;
10065 }
10066 }
10067 if (obj3) {
10068 {
10069 arg4 = (bool)(SWIG_As_bool(obj3));
10070 if (SWIG_arg_fail(4)) SWIG_fail;
10071 }
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10076
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 {
10081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10082 }
10083 return resultobj;
10084 fail:
10085 return NULL;
10086 }
10087
10088
10089 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj;
10091 wxGrid *arg1 = (wxGrid *) 0 ;
10092 int arg2 = (int) 1 ;
10093 bool arg3 = (bool) true ;
10094 bool result;
10095 PyObject * obj0 = 0 ;
10096 PyObject * obj1 = 0 ;
10097 PyObject * obj2 = 0 ;
10098 char *kwnames[] = {
10099 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10100 };
10101
10102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10104 if (SWIG_arg_fail(1)) SWIG_fail;
10105 if (obj1) {
10106 {
10107 arg2 = (int)(SWIG_As_int(obj1));
10108 if (SWIG_arg_fail(2)) SWIG_fail;
10109 }
10110 }
10111 if (obj2) {
10112 {
10113 arg3 = (bool)(SWIG_As_bool(obj2));
10114 if (SWIG_arg_fail(3)) SWIG_fail;
10115 }
10116 }
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (bool)(arg1)->AppendRows(arg2,arg3);
10120
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj;
10135 wxGrid *arg1 = (wxGrid *) 0 ;
10136 int arg2 = (int) 0 ;
10137 int arg3 = (int) 1 ;
10138 bool arg4 = (bool) true ;
10139 bool result;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 PyObject * obj2 = 0 ;
10143 PyObject * obj3 = 0 ;
10144 char *kwnames[] = {
10145 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10146 };
10147
10148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10150 if (SWIG_arg_fail(1)) SWIG_fail;
10151 if (obj1) {
10152 {
10153 arg2 = (int)(SWIG_As_int(obj1));
10154 if (SWIG_arg_fail(2)) SWIG_fail;
10155 }
10156 }
10157 if (obj2) {
10158 {
10159 arg3 = (int)(SWIG_As_int(obj2));
10160 if (SWIG_arg_fail(3)) SWIG_fail;
10161 }
10162 }
10163 if (obj3) {
10164 {
10165 arg4 = (bool)(SWIG_As_bool(obj3));
10166 if (SWIG_arg_fail(4)) SWIG_fail;
10167 }
10168 }
10169 {
10170 PyThreadState* __tstate = wxPyBeginAllowThreads();
10171 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10172
10173 wxPyEndAllowThreads(__tstate);
10174 if (PyErr_Occurred()) SWIG_fail;
10175 }
10176 {
10177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10178 }
10179 return resultobj;
10180 fail:
10181 return NULL;
10182 }
10183
10184
10185 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10186 PyObject *resultobj;
10187 wxGrid *arg1 = (wxGrid *) 0 ;
10188 int arg2 = (int) 0 ;
10189 int arg3 = (int) 1 ;
10190 bool arg4 = (bool) true ;
10191 bool result;
10192 PyObject * obj0 = 0 ;
10193 PyObject * obj1 = 0 ;
10194 PyObject * obj2 = 0 ;
10195 PyObject * obj3 = 0 ;
10196 char *kwnames[] = {
10197 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10198 };
10199
10200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10202 if (SWIG_arg_fail(1)) SWIG_fail;
10203 if (obj1) {
10204 {
10205 arg2 = (int)(SWIG_As_int(obj1));
10206 if (SWIG_arg_fail(2)) SWIG_fail;
10207 }
10208 }
10209 if (obj2) {
10210 {
10211 arg3 = (int)(SWIG_As_int(obj2));
10212 if (SWIG_arg_fail(3)) SWIG_fail;
10213 }
10214 }
10215 if (obj3) {
10216 {
10217 arg4 = (bool)(SWIG_As_bool(obj3));
10218 if (SWIG_arg_fail(4)) SWIG_fail;
10219 }
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 {
10229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10230 }
10231 return resultobj;
10232 fail:
10233 return NULL;
10234 }
10235
10236
10237 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10238 PyObject *resultobj;
10239 wxGrid *arg1 = (wxGrid *) 0 ;
10240 int arg2 = (int) 1 ;
10241 bool arg3 = (bool) true ;
10242 bool result;
10243 PyObject * obj0 = 0 ;
10244 PyObject * obj1 = 0 ;
10245 PyObject * obj2 = 0 ;
10246 char *kwnames[] = {
10247 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10248 };
10249
10250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10252 if (SWIG_arg_fail(1)) SWIG_fail;
10253 if (obj1) {
10254 {
10255 arg2 = (int)(SWIG_As_int(obj1));
10256 if (SWIG_arg_fail(2)) SWIG_fail;
10257 }
10258 }
10259 if (obj2) {
10260 {
10261 arg3 = (bool)(SWIG_As_bool(obj2));
10262 if (SWIG_arg_fail(3)) SWIG_fail;
10263 }
10264 }
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (bool)(arg1)->AppendCols(arg2,arg3);
10268
10269 wxPyEndAllowThreads(__tstate);
10270 if (PyErr_Occurred()) SWIG_fail;
10271 }
10272 {
10273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10274 }
10275 return resultobj;
10276 fail:
10277 return NULL;
10278 }
10279
10280
10281 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj;
10283 wxGrid *arg1 = (wxGrid *) 0 ;
10284 int arg2 = (int) 0 ;
10285 int arg3 = (int) 1 ;
10286 bool arg4 = (bool) true ;
10287 bool result;
10288 PyObject * obj0 = 0 ;
10289 PyObject * obj1 = 0 ;
10290 PyObject * obj2 = 0 ;
10291 PyObject * obj3 = 0 ;
10292 char *kwnames[] = {
10293 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10294 };
10295
10296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10298 if (SWIG_arg_fail(1)) SWIG_fail;
10299 if (obj1) {
10300 {
10301 arg2 = (int)(SWIG_As_int(obj1));
10302 if (SWIG_arg_fail(2)) SWIG_fail;
10303 }
10304 }
10305 if (obj2) {
10306 {
10307 arg3 = (int)(SWIG_As_int(obj2));
10308 if (SWIG_arg_fail(3)) SWIG_fail;
10309 }
10310 }
10311 if (obj3) {
10312 {
10313 arg4 = (bool)(SWIG_As_bool(obj3));
10314 if (SWIG_arg_fail(4)) SWIG_fail;
10315 }
10316 }
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10320
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 {
10325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10326 }
10327 return resultobj;
10328 fail:
10329 return NULL;
10330 }
10331
10332
10333 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10334 PyObject *resultobj;
10335 wxGrid *arg1 = (wxGrid *) 0 ;
10336 wxDC *arg2 = 0 ;
10337 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char *kwnames[] = {
10342 (char *) "self",(char *) "dc",(char *) "attr", NULL
10343 };
10344
10345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10347 if (SWIG_arg_fail(1)) SWIG_fail;
10348 {
10349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10350 if (SWIG_arg_fail(2)) SWIG_fail;
10351 if (arg2 == NULL) {
10352 SWIG_null_ref("wxDC");
10353 }
10354 if (SWIG_arg_fail(2)) SWIG_fail;
10355 }
10356 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10357 if (SWIG_arg_fail(3)) SWIG_fail;
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10361
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 Py_INCREF(Py_None); resultobj = Py_None;
10366 return resultobj;
10367 fail:
10368 return NULL;
10369 }
10370
10371
10372 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj;
10374 wxGrid *arg1 = (wxGrid *) 0 ;
10375 wxDC *arg2 = 0 ;
10376 wxString *arg3 = 0 ;
10377 wxRect *arg4 = 0 ;
10378 int arg5 = (int) wxLEFT ;
10379 int arg6 = (int) wxTOP ;
10380 int arg7 = (int) wxHORIZONTAL ;
10381 bool temp3 = false ;
10382 wxRect temp4 ;
10383 PyObject * obj0 = 0 ;
10384 PyObject * obj1 = 0 ;
10385 PyObject * obj2 = 0 ;
10386 PyObject * obj3 = 0 ;
10387 PyObject * obj4 = 0 ;
10388 PyObject * obj5 = 0 ;
10389 PyObject * obj6 = 0 ;
10390 char *kwnames[] = {
10391 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10392 };
10393
10394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10396 if (SWIG_arg_fail(1)) SWIG_fail;
10397 {
10398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10399 if (SWIG_arg_fail(2)) SWIG_fail;
10400 if (arg2 == NULL) {
10401 SWIG_null_ref("wxDC");
10402 }
10403 if (SWIG_arg_fail(2)) SWIG_fail;
10404 }
10405 {
10406 arg3 = wxString_in_helper(obj2);
10407 if (arg3 == NULL) SWIG_fail;
10408 temp3 = true;
10409 }
10410 {
10411 arg4 = &temp4;
10412 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10413 }
10414 if (obj4) {
10415 {
10416 arg5 = (int)(SWIG_As_int(obj4));
10417 if (SWIG_arg_fail(5)) SWIG_fail;
10418 }
10419 }
10420 if (obj5) {
10421 {
10422 arg6 = (int)(SWIG_As_int(obj5));
10423 if (SWIG_arg_fail(6)) SWIG_fail;
10424 }
10425 }
10426 if (obj6) {
10427 {
10428 arg7 = (int)(SWIG_As_int(obj6));
10429 if (SWIG_arg_fail(7)) SWIG_fail;
10430 }
10431 }
10432 {
10433 PyThreadState* __tstate = wxPyBeginAllowThreads();
10434 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10435
10436 wxPyEndAllowThreads(__tstate);
10437 if (PyErr_Occurred()) SWIG_fail;
10438 }
10439 Py_INCREF(Py_None); resultobj = Py_None;
10440 {
10441 if (temp3)
10442 delete arg3;
10443 }
10444 return resultobj;
10445 fail:
10446 {
10447 if (temp3)
10448 delete arg3;
10449 }
10450 return NULL;
10451 }
10452
10453
10454 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10455 PyObject *resultobj;
10456 wxGrid *arg1 = (wxGrid *) 0 ;
10457 wxDC *arg2 = 0 ;
10458 wxArrayString *arg3 = 0 ;
10459 long *arg4 = (long *) 0 ;
10460 long *arg5 = (long *) 0 ;
10461 bool temp3 = false ;
10462 long temp4 ;
10463 int res4 = 0 ;
10464 long temp5 ;
10465 int res5 = 0 ;
10466 PyObject * obj0 = 0 ;
10467 PyObject * obj1 = 0 ;
10468 PyObject * obj2 = 0 ;
10469 char *kwnames[] = {
10470 (char *) "self",(char *) "dc",(char *) "lines", NULL
10471 };
10472
10473 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10474 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10477 if (SWIG_arg_fail(1)) SWIG_fail;
10478 {
10479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10480 if (SWIG_arg_fail(2)) SWIG_fail;
10481 if (arg2 == NULL) {
10482 SWIG_null_ref("wxDC");
10483 }
10484 if (SWIG_arg_fail(2)) SWIG_fail;
10485 }
10486 {
10487 if (! PySequence_Check(obj2)) {
10488 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10489 SWIG_fail;
10490 }
10491 arg3 = new wxArrayString;
10492 temp3 = true;
10493 int i, len=PySequence_Length(obj2);
10494 for (i=0; i<len; i++) {
10495 PyObject* item = PySequence_GetItem(obj2, i);
10496 #if wxUSE_UNICODE
10497 PyObject* str = PyObject_Unicode(item);
10498 #else
10499 PyObject* str = PyObject_Str(item);
10500 #endif
10501 if (PyErr_Occurred()) SWIG_fail;
10502 arg3->Add(Py2wxString(str));
10503 Py_DECREF(item);
10504 Py_DECREF(str);
10505 }
10506 }
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10510
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 Py_INCREF(Py_None); resultobj = Py_None;
10515 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10516 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10517 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10518 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10519 {
10520 if (temp3) delete arg3;
10521 }
10522 return resultobj;
10523 fail:
10524 {
10525 if (temp3) delete arg3;
10526 }
10527 return NULL;
10528 }
10529
10530
10531 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10532 PyObject *resultobj;
10533 wxGrid *arg1 = (wxGrid *) 0 ;
10534 PyObject * obj0 = 0 ;
10535 char *kwnames[] = {
10536 (char *) "self", NULL
10537 };
10538
10539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10541 if (SWIG_arg_fail(1)) SWIG_fail;
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 (arg1)->BeginBatch();
10545
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 Py_INCREF(Py_None); resultobj = Py_None;
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj;
10558 wxGrid *arg1 = (wxGrid *) 0 ;
10559 PyObject * obj0 = 0 ;
10560 char *kwnames[] = {
10561 (char *) "self", NULL
10562 };
10563
10564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10566 if (SWIG_arg_fail(1)) SWIG_fail;
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 (arg1)->EndBatch();
10570
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 Py_INCREF(Py_None); resultobj = Py_None;
10575 return resultobj;
10576 fail:
10577 return NULL;
10578 }
10579
10580
10581 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10582 PyObject *resultobj;
10583 wxGrid *arg1 = (wxGrid *) 0 ;
10584 int result;
10585 PyObject * obj0 = 0 ;
10586 char *kwnames[] = {
10587 (char *) "self", NULL
10588 };
10589
10590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10592 if (SWIG_arg_fail(1)) SWIG_fail;
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (int)(arg1)->GetBatchCount();
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 {
10601 resultobj = SWIG_From_int((int)(result));
10602 }
10603 return resultobj;
10604 fail:
10605 return NULL;
10606 }
10607
10608
10609 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10610 PyObject *resultobj;
10611 wxGrid *arg1 = (wxGrid *) 0 ;
10612 PyObject * obj0 = 0 ;
10613 char *kwnames[] = {
10614 (char *) "self", NULL
10615 };
10616
10617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10619 if (SWIG_arg_fail(1)) SWIG_fail;
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 (arg1)->ForceRefresh();
10623
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 Py_INCREF(Py_None); resultobj = Py_None;
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj;
10636 wxGrid *arg1 = (wxGrid *) 0 ;
10637 bool result;
10638 PyObject * obj0 = 0 ;
10639 char *kwnames[] = {
10640 (char *) "self", NULL
10641 };
10642
10643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10645 if (SWIG_arg_fail(1)) SWIG_fail;
10646 {
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 result = (bool)(arg1)->IsEditable();
10649
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 {
10654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10655 }
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10663 PyObject *resultobj;
10664 wxGrid *arg1 = (wxGrid *) 0 ;
10665 bool arg2 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char *kwnames[] = {
10669 (char *) "self",(char *) "edit", NULL
10670 };
10671
10672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10674 if (SWIG_arg_fail(1)) SWIG_fail;
10675 {
10676 arg2 = (bool)(SWIG_As_bool(obj1));
10677 if (SWIG_arg_fail(2)) SWIG_fail;
10678 }
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 (arg1)->EnableEditing(arg2);
10682
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 Py_INCREF(Py_None); resultobj = Py_None;
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj;
10695 wxGrid *arg1 = (wxGrid *) 0 ;
10696 bool arg2 = (bool) true ;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "self",(char *) "enable", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10705 if (SWIG_arg_fail(1)) SWIG_fail;
10706 if (obj1) {
10707 {
10708 arg2 = (bool)(SWIG_As_bool(obj1));
10709 if (SWIG_arg_fail(2)) SWIG_fail;
10710 }
10711 }
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 (arg1)->EnableCellEditControl(arg2);
10715
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 Py_INCREF(Py_None); resultobj = Py_None;
10720 return resultobj;
10721 fail:
10722 return NULL;
10723 }
10724
10725
10726 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10727 PyObject *resultobj;
10728 wxGrid *arg1 = (wxGrid *) 0 ;
10729 PyObject * obj0 = 0 ;
10730 char *kwnames[] = {
10731 (char *) "self", NULL
10732 };
10733
10734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10736 if (SWIG_arg_fail(1)) SWIG_fail;
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 (arg1)->DisableCellEditControl();
10740
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 Py_INCREF(Py_None); resultobj = Py_None;
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj;
10753 wxGrid *arg1 = (wxGrid *) 0 ;
10754 bool result;
10755 PyObject * obj0 = 0 ;
10756 char *kwnames[] = {
10757 (char *) "self", NULL
10758 };
10759
10760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 {
10764 PyThreadState* __tstate = wxPyBeginAllowThreads();
10765 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10766
10767 wxPyEndAllowThreads(__tstate);
10768 if (PyErr_Occurred()) SWIG_fail;
10769 }
10770 {
10771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10772 }
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj;
10781 wxGrid *arg1 = (wxGrid *) 0 ;
10782 bool result;
10783 PyObject * obj0 = 0 ;
10784 char *kwnames[] = {
10785 (char *) "self", NULL
10786 };
10787
10788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
10789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10790 if (SWIG_arg_fail(1)) SWIG_fail;
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 {
10799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10800 }
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
10808 PyObject *resultobj;
10809 wxGrid *arg1 = (wxGrid *) 0 ;
10810 bool result;
10811 PyObject * obj0 = 0 ;
10812 char *kwnames[] = {
10813 (char *) "self", NULL
10814 };
10815
10816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
10817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10818 if (SWIG_arg_fail(1)) SWIG_fail;
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
10822
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 {
10827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10828 }
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj;
10837 wxGrid *arg1 = (wxGrid *) 0 ;
10838 bool result;
10839 PyObject * obj0 = 0 ;
10840 char *kwnames[] = {
10841 (char *) "self", NULL
10842 };
10843
10844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
10845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10846 if (SWIG_arg_fail(1)) SWIG_fail;
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
10850
10851 wxPyEndAllowThreads(__tstate);
10852 if (PyErr_Occurred()) SWIG_fail;
10853 }
10854 {
10855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10856 }
10857 return resultobj;
10858 fail:
10859 return NULL;
10860 }
10861
10862
10863 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10864 PyObject *resultobj;
10865 wxGrid *arg1 = (wxGrid *) 0 ;
10866 PyObject * obj0 = 0 ;
10867 char *kwnames[] = {
10868 (char *) "self", NULL
10869 };
10870
10871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
10872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10873 if (SWIG_arg_fail(1)) SWIG_fail;
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 (arg1)->ShowCellEditControl();
10877
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 Py_INCREF(Py_None); resultobj = Py_None;
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxGrid *arg1 = (wxGrid *) 0 ;
10891 PyObject * obj0 = 0 ;
10892 char *kwnames[] = {
10893 (char *) "self", NULL
10894 };
10895
10896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
10897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10898 if (SWIG_arg_fail(1)) SWIG_fail;
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 (arg1)->HideCellEditControl();
10902
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 Py_INCREF(Py_None); resultobj = Py_None;
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj;
10915 wxGrid *arg1 = (wxGrid *) 0 ;
10916 PyObject * obj0 = 0 ;
10917 char *kwnames[] = {
10918 (char *) "self", NULL
10919 };
10920
10921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
10922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10923 if (SWIG_arg_fail(1)) SWIG_fail;
10924 {
10925 PyThreadState* __tstate = wxPyBeginAllowThreads();
10926 (arg1)->SaveEditControlValue();
10927
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 Py_INCREF(Py_None); resultobj = Py_None;
10932 return resultobj;
10933 fail:
10934 return NULL;
10935 }
10936
10937
10938 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
10939 PyObject *resultobj;
10940 wxGrid *arg1 = (wxGrid *) 0 ;
10941 int arg2 ;
10942 int arg3 ;
10943 wxGridCellCoords result;
10944 PyObject * obj0 = 0 ;
10945 PyObject * obj1 = 0 ;
10946 PyObject * obj2 = 0 ;
10947 char *kwnames[] = {
10948 (char *) "self",(char *) "x",(char *) "y", NULL
10949 };
10950
10951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
10952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10953 if (SWIG_arg_fail(1)) SWIG_fail;
10954 {
10955 arg2 = (int)(SWIG_As_int(obj1));
10956 if (SWIG_arg_fail(2)) SWIG_fail;
10957 }
10958 {
10959 arg3 = (int)(SWIG_As_int(obj2));
10960 if (SWIG_arg_fail(3)) SWIG_fail;
10961 }
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 result = wxGrid_XYToCell(arg1,arg2,arg3);
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 {
10970 wxGridCellCoords * resultptr;
10971 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
10972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
10973 }
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj;
10982 wxGrid *arg1 = (wxGrid *) 0 ;
10983 int arg2 ;
10984 int result;
10985 PyObject * obj0 = 0 ;
10986 PyObject * obj1 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "self",(char *) "y", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
10992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10993 if (SWIG_arg_fail(1)) SWIG_fail;
10994 {
10995 arg2 = (int)(SWIG_As_int(obj1));
10996 if (SWIG_arg_fail(2)) SWIG_fail;
10997 }
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 result = (int)(arg1)->YToRow(arg2);
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = SWIG_From_int((int)(result));
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxGrid *arg1 = (wxGrid *) 0 ;
11017 int arg2 ;
11018 int result;
11019 PyObject * obj0 = 0 ;
11020 PyObject * obj1 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self",(char *) "x", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 arg2 = (int)(SWIG_As_int(obj1));
11030 if (SWIG_arg_fail(2)) SWIG_fail;
11031 }
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = (int)(arg1)->XToCol(arg2);
11035
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 resultobj = SWIG_From_int((int)(result));
11041 }
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj;
11050 wxGrid *arg1 = (wxGrid *) 0 ;
11051 int arg2 ;
11052 int result;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 char *kwnames[] = {
11056 (char *) "self",(char *) "y", NULL
11057 };
11058
11059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11061 if (SWIG_arg_fail(1)) SWIG_fail;
11062 {
11063 arg2 = (int)(SWIG_As_int(obj1));
11064 if (SWIG_arg_fail(2)) SWIG_fail;
11065 }
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 result = (int)(arg1)->YToEdgeOfRow(arg2);
11069
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 {
11074 resultobj = SWIG_From_int((int)(result));
11075 }
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj;
11084 wxGrid *arg1 = (wxGrid *) 0 ;
11085 int arg2 ;
11086 int result;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 char *kwnames[] = {
11090 (char *) "self",(char *) "x", NULL
11091 };
11092
11093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11095 if (SWIG_arg_fail(1)) SWIG_fail;
11096 {
11097 arg2 = (int)(SWIG_As_int(obj1));
11098 if (SWIG_arg_fail(2)) SWIG_fail;
11099 }
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = (int)(arg1)->XToEdgeOfCol(arg2);
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 {
11108 resultobj = SWIG_From_int((int)(result));
11109 }
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11117 PyObject *resultobj;
11118 wxGrid *arg1 = (wxGrid *) 0 ;
11119 int arg2 ;
11120 int arg3 ;
11121 wxRect result;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char *kwnames[] = {
11126 (char *) "self",(char *) "row",(char *) "col", NULL
11127 };
11128
11129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11131 if (SWIG_arg_fail(1)) SWIG_fail;
11132 {
11133 arg2 = (int)(SWIG_As_int(obj1));
11134 if (SWIG_arg_fail(2)) SWIG_fail;
11135 }
11136 {
11137 arg3 = (int)(SWIG_As_int(obj2));
11138 if (SWIG_arg_fail(3)) SWIG_fail;
11139 }
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 result = (arg1)->CellToRect(arg2,arg3);
11143
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 {
11148 wxRect * resultptr;
11149 resultptr = new wxRect((wxRect &)(result));
11150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11151 }
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj;
11160 wxGrid *arg1 = (wxGrid *) 0 ;
11161 int result;
11162 PyObject * obj0 = 0 ;
11163 char *kwnames[] = {
11164 (char *) "self", NULL
11165 };
11166
11167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11169 if (SWIG_arg_fail(1)) SWIG_fail;
11170 {
11171 PyThreadState* __tstate = wxPyBeginAllowThreads();
11172 result = (int)(arg1)->GetGridCursorRow();
11173
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 {
11178 resultobj = SWIG_From_int((int)(result));
11179 }
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11187 PyObject *resultobj;
11188 wxGrid *arg1 = (wxGrid *) 0 ;
11189 int result;
11190 PyObject * obj0 = 0 ;
11191 char *kwnames[] = {
11192 (char *) "self", NULL
11193 };
11194
11195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11197 if (SWIG_arg_fail(1)) SWIG_fail;
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 result = (int)(arg1)->GetGridCursorCol();
11201
11202 wxPyEndAllowThreads(__tstate);
11203 if (PyErr_Occurred()) SWIG_fail;
11204 }
11205 {
11206 resultobj = SWIG_From_int((int)(result));
11207 }
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj;
11216 wxGrid *arg1 = (wxGrid *) 0 ;
11217 int arg2 ;
11218 int arg3 ;
11219 bool arg4 = (bool) true ;
11220 bool result;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 PyObject * obj3 = 0 ;
11225 char *kwnames[] = {
11226 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11227 };
11228
11229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11231 if (SWIG_arg_fail(1)) SWIG_fail;
11232 {
11233 arg2 = (int)(SWIG_As_int(obj1));
11234 if (SWIG_arg_fail(2)) SWIG_fail;
11235 }
11236 {
11237 arg3 = (int)(SWIG_As_int(obj2));
11238 if (SWIG_arg_fail(3)) SWIG_fail;
11239 }
11240 if (obj3) {
11241 {
11242 arg4 = (bool)(SWIG_As_bool(obj3));
11243 if (SWIG_arg_fail(4)) SWIG_fail;
11244 }
11245 }
11246 {
11247 PyThreadState* __tstate = wxPyBeginAllowThreads();
11248 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11249
11250 wxPyEndAllowThreads(__tstate);
11251 if (PyErr_Occurred()) SWIG_fail;
11252 }
11253 {
11254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11255 }
11256 return resultobj;
11257 fail:
11258 return NULL;
11259 }
11260
11261
11262 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11263 PyObject *resultobj;
11264 wxGrid *arg1 = (wxGrid *) 0 ;
11265 int arg2 ;
11266 int arg3 ;
11267 PyObject * obj0 = 0 ;
11268 PyObject * obj1 = 0 ;
11269 PyObject * obj2 = 0 ;
11270 char *kwnames[] = {
11271 (char *) "self",(char *) "row",(char *) "col", NULL
11272 };
11273
11274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11276 if (SWIG_arg_fail(1)) SWIG_fail;
11277 {
11278 arg2 = (int)(SWIG_As_int(obj1));
11279 if (SWIG_arg_fail(2)) SWIG_fail;
11280 }
11281 {
11282 arg3 = (int)(SWIG_As_int(obj2));
11283 if (SWIG_arg_fail(3)) SWIG_fail;
11284 }
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 (arg1)->MakeCellVisible(arg2,arg3);
11288
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 Py_INCREF(Py_None); resultobj = Py_None;
11293 return resultobj;
11294 fail:
11295 return NULL;
11296 }
11297
11298
11299 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj;
11301 wxGrid *arg1 = (wxGrid *) 0 ;
11302 int arg2 ;
11303 int arg3 ;
11304 PyObject * obj0 = 0 ;
11305 PyObject * obj1 = 0 ;
11306 PyObject * obj2 = 0 ;
11307 char *kwnames[] = {
11308 (char *) "self",(char *) "row",(char *) "col", NULL
11309 };
11310
11311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11313 if (SWIG_arg_fail(1)) SWIG_fail;
11314 {
11315 arg2 = (int)(SWIG_As_int(obj1));
11316 if (SWIG_arg_fail(2)) SWIG_fail;
11317 }
11318 {
11319 arg3 = (int)(SWIG_As_int(obj2));
11320 if (SWIG_arg_fail(3)) SWIG_fail;
11321 }
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 (arg1)->SetGridCursor(arg2,arg3);
11325
11326 wxPyEndAllowThreads(__tstate);
11327 if (PyErr_Occurred()) SWIG_fail;
11328 }
11329 Py_INCREF(Py_None); resultobj = Py_None;
11330 return resultobj;
11331 fail:
11332 return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj;
11338 wxGrid *arg1 = (wxGrid *) 0 ;
11339 bool arg2 ;
11340 bool result;
11341 PyObject * obj0 = 0 ;
11342 PyObject * obj1 = 0 ;
11343 char *kwnames[] = {
11344 (char *) "self",(char *) "expandSelection", NULL
11345 };
11346
11347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11349 if (SWIG_arg_fail(1)) SWIG_fail;
11350 {
11351 arg2 = (bool)(SWIG_As_bool(obj1));
11352 if (SWIG_arg_fail(2)) SWIG_fail;
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (bool)(arg1)->MoveCursorUp(arg2);
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11363 }
11364 return resultobj;
11365 fail:
11366 return NULL;
11367 }
11368
11369
11370 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj;
11372 wxGrid *arg1 = (wxGrid *) 0 ;
11373 bool arg2 ;
11374 bool result;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 char *kwnames[] = {
11378 (char *) "self",(char *) "expandSelection", NULL
11379 };
11380
11381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11383 if (SWIG_arg_fail(1)) SWIG_fail;
11384 {
11385 arg2 = (bool)(SWIG_As_bool(obj1));
11386 if (SWIG_arg_fail(2)) SWIG_fail;
11387 }
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = (bool)(arg1)->MoveCursorDown(arg2);
11391
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 {
11396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11397 }
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj;
11406 wxGrid *arg1 = (wxGrid *) 0 ;
11407 bool arg2 ;
11408 bool result;
11409 PyObject * obj0 = 0 ;
11410 PyObject * obj1 = 0 ;
11411 char *kwnames[] = {
11412 (char *) "self",(char *) "expandSelection", NULL
11413 };
11414
11415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11417 if (SWIG_arg_fail(1)) SWIG_fail;
11418 {
11419 arg2 = (bool)(SWIG_As_bool(obj1));
11420 if (SWIG_arg_fail(2)) SWIG_fail;
11421 }
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (bool)(arg1)->MoveCursorLeft(arg2);
11425
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 {
11430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11431 }
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj;
11440 wxGrid *arg1 = (wxGrid *) 0 ;
11441 bool arg2 ;
11442 bool result;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "expandSelection", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = (bool)(SWIG_As_bool(obj1));
11454 if (SWIG_arg_fail(2)) SWIG_fail;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (bool)(arg1)->MoveCursorRight(arg2);
11459
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 {
11464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 wxGrid *arg1 = (wxGrid *) 0 ;
11475 bool result;
11476 PyObject * obj0 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "self", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->MovePageDown();
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj;
11502 wxGrid *arg1 = (wxGrid *) 0 ;
11503 bool result;
11504 PyObject * obj0 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (bool)(arg1)->MovePageUp();
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11521 }
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 static PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj;
11530 wxGrid *arg1 = (wxGrid *) 0 ;
11531 bool arg2 ;
11532 bool result;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 char *kwnames[] = {
11536 (char *) "self",(char *) "expandSelection", NULL
11537 };
11538
11539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) goto fail;
11540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11541 if (SWIG_arg_fail(1)) SWIG_fail;
11542 {
11543 arg2 = (bool)(SWIG_As_bool(obj1));
11544 if (SWIG_arg_fail(2)) SWIG_fail;
11545 }
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
11549
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 static PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11563 PyObject *resultobj;
11564 wxGrid *arg1 = (wxGrid *) 0 ;
11565 bool arg2 ;
11566 bool result;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "self",(char *) "expandSelection", NULL
11571 };
11572
11573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) goto fail;
11574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11575 if (SWIG_arg_fail(1)) SWIG_fail;
11576 {
11577 arg2 = (bool)(SWIG_As_bool(obj1));
11578 if (SWIG_arg_fail(2)) SWIG_fail;
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
11583
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 {
11588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11589 }
11590 return resultobj;
11591 fail:
11592 return NULL;
11593 }
11594
11595
11596 static PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11597 PyObject *resultobj;
11598 wxGrid *arg1 = (wxGrid *) 0 ;
11599 bool arg2 ;
11600 bool result;
11601 PyObject * obj0 = 0 ;
11602 PyObject * obj1 = 0 ;
11603 char *kwnames[] = {
11604 (char *) "self",(char *) "expandSelection", NULL
11605 };
11606
11607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) goto fail;
11608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11609 if (SWIG_arg_fail(1)) SWIG_fail;
11610 {
11611 arg2 = (bool)(SWIG_As_bool(obj1));
11612 if (SWIG_arg_fail(2)) SWIG_fail;
11613 }
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
11617
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11623 }
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj;
11632 wxGrid *arg1 = (wxGrid *) 0 ;
11633 bool arg2 ;
11634 bool result;
11635 PyObject * obj0 = 0 ;
11636 PyObject * obj1 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self",(char *) "expandSelection", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 arg2 = (bool)(SWIG_As_bool(obj1));
11646 if (SWIG_arg_fail(2)) SWIG_fail;
11647 }
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 {
11656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11657 }
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj;
11666 wxGrid *arg1 = (wxGrid *) 0 ;
11667 int result;
11668 PyObject * obj0 = 0 ;
11669 char *kwnames[] = {
11670 (char *) "self", NULL
11671 };
11672
11673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11675 if (SWIG_arg_fail(1)) SWIG_fail;
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (int)(arg1)->GetDefaultRowLabelSize();
11679
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 {
11684 resultobj = SWIG_From_int((int)(result));
11685 }
11686 return resultobj;
11687 fail:
11688 return NULL;
11689 }
11690
11691
11692 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11693 PyObject *resultobj;
11694 wxGrid *arg1 = (wxGrid *) 0 ;
11695 int result;
11696 PyObject * obj0 = 0 ;
11697 char *kwnames[] = {
11698 (char *) "self", NULL
11699 };
11700
11701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11703 if (SWIG_arg_fail(1)) SWIG_fail;
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (int)(arg1)->GetRowLabelSize();
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 resultobj = SWIG_From_int((int)(result));
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11721 PyObject *resultobj;
11722 wxGrid *arg1 = (wxGrid *) 0 ;
11723 int result;
11724 PyObject * obj0 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "self", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(1)) SWIG_fail;
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 result = (int)(arg1)->GetDefaultColLabelSize();
11735
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 {
11740 resultobj = SWIG_From_int((int)(result));
11741 }
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj;
11750 wxGrid *arg1 = (wxGrid *) 0 ;
11751 int result;
11752 PyObject * obj0 = 0 ;
11753 char *kwnames[] = {
11754 (char *) "self", NULL
11755 };
11756
11757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11759 if (SWIG_arg_fail(1)) SWIG_fail;
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 result = (int)(arg1)->GetColLabelSize();
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 {
11768 resultobj = SWIG_From_int((int)(result));
11769 }
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj;
11778 wxGrid *arg1 = (wxGrid *) 0 ;
11779 wxColour result;
11780 PyObject * obj0 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "self", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
11786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11787 if (SWIG_arg_fail(1)) SWIG_fail;
11788 {
11789 PyThreadState* __tstate = wxPyBeginAllowThreads();
11790 result = (arg1)->GetLabelBackgroundColour();
11791
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 {
11796 wxColour * resultptr;
11797 resultptr = new wxColour((wxColour &)(result));
11798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11799 }
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
11807 PyObject *resultobj;
11808 wxGrid *arg1 = (wxGrid *) 0 ;
11809 wxColour result;
11810 PyObject * obj0 = 0 ;
11811 char *kwnames[] = {
11812 (char *) "self", NULL
11813 };
11814
11815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
11816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11817 if (SWIG_arg_fail(1)) SWIG_fail;
11818 {
11819 PyThreadState* __tstate = wxPyBeginAllowThreads();
11820 result = (arg1)->GetLabelTextColour();
11821
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 {
11826 wxColour * resultptr;
11827 resultptr = new wxColour((wxColour &)(result));
11828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11829 }
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
11837 PyObject *resultobj;
11838 wxGrid *arg1 = (wxGrid *) 0 ;
11839 wxFont result;
11840 PyObject * obj0 = 0 ;
11841 char *kwnames[] = {
11842 (char *) "self", NULL
11843 };
11844
11845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
11846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11847 if (SWIG_arg_fail(1)) SWIG_fail;
11848 {
11849 PyThreadState* __tstate = wxPyBeginAllowThreads();
11850 result = (arg1)->GetLabelFont();
11851
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 wxFont * resultptr;
11857 resultptr = new wxFont((wxFont &)(result));
11858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
11859 }
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11867 PyObject *resultobj;
11868 wxGrid *arg1 = (wxGrid *) 0 ;
11869 int *arg2 = (int *) 0 ;
11870 int *arg3 = (int *) 0 ;
11871 int temp2 ;
11872 int res2 = 0 ;
11873 int temp3 ;
11874 int res3 = 0 ;
11875 PyObject * obj0 = 0 ;
11876 char *kwnames[] = {
11877 (char *) "self", NULL
11878 };
11879
11880 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11881 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
11883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11884 if (SWIG_arg_fail(1)) SWIG_fail;
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 (arg1)->GetRowLabelAlignment(arg2,arg3);
11888
11889 wxPyEndAllowThreads(__tstate);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 Py_INCREF(Py_None); resultobj = Py_None;
11893 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11894 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11895 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11896 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj;
11905 wxGrid *arg1 = (wxGrid *) 0 ;
11906 int *arg2 = (int *) 0 ;
11907 int *arg3 = (int *) 0 ;
11908 int temp2 ;
11909 int res2 = 0 ;
11910 int temp3 ;
11911 int res3 = 0 ;
11912 PyObject * obj0 = 0 ;
11913 char *kwnames[] = {
11914 (char *) "self", NULL
11915 };
11916
11917 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11918 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
11920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11921 if (SWIG_arg_fail(1)) SWIG_fail;
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 (arg1)->GetColLabelAlignment(arg2,arg3);
11925
11926 wxPyEndAllowThreads(__tstate);
11927 if (PyErr_Occurred()) SWIG_fail;
11928 }
11929 Py_INCREF(Py_None); resultobj = Py_None;
11930 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11931 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11932 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11933 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11934 return resultobj;
11935 fail:
11936 return NULL;
11937 }
11938
11939
11940 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
11941 PyObject *resultobj;
11942 wxGrid *arg1 = (wxGrid *) 0 ;
11943 int result;
11944 PyObject * obj0 = 0 ;
11945 char *kwnames[] = {
11946 (char *) "self", NULL
11947 };
11948
11949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
11950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11951 if (SWIG_arg_fail(1)) SWIG_fail;
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (int)(arg1)->GetColLabelTextOrientation();
11955
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 {
11960 resultobj = SWIG_From_int((int)(result));
11961 }
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj;
11970 wxGrid *arg1 = (wxGrid *) 0 ;
11971 int arg2 ;
11972 wxString result;
11973 PyObject * obj0 = 0 ;
11974 PyObject * obj1 = 0 ;
11975 char *kwnames[] = {
11976 (char *) "self",(char *) "row", NULL
11977 };
11978
11979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
11980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11981 if (SWIG_arg_fail(1)) SWIG_fail;
11982 {
11983 arg2 = (int)(SWIG_As_int(obj1));
11984 if (SWIG_arg_fail(2)) SWIG_fail;
11985 }
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (arg1)->GetRowLabelValue(arg2);
11989
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 {
11994 #if wxUSE_UNICODE
11995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11996 #else
11997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11998 #endif
11999 }
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12007 PyObject *resultobj;
12008 wxGrid *arg1 = (wxGrid *) 0 ;
12009 int arg2 ;
12010 wxString result;
12011 PyObject * obj0 = 0 ;
12012 PyObject * obj1 = 0 ;
12013 char *kwnames[] = {
12014 (char *) "self",(char *) "col", NULL
12015 };
12016
12017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12019 if (SWIG_arg_fail(1)) SWIG_fail;
12020 {
12021 arg2 = (int)(SWIG_As_int(obj1));
12022 if (SWIG_arg_fail(2)) SWIG_fail;
12023 }
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (arg1)->GetColLabelValue(arg2);
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 #if wxUSE_UNICODE
12033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12034 #else
12035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12036 #endif
12037 }
12038 return resultobj;
12039 fail:
12040 return NULL;
12041 }
12042
12043
12044 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12045 PyObject *resultobj;
12046 wxGrid *arg1 = (wxGrid *) 0 ;
12047 wxColour result;
12048 PyObject * obj0 = 0 ;
12049 char *kwnames[] = {
12050 (char *) "self", NULL
12051 };
12052
12053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12055 if (SWIG_arg_fail(1)) SWIG_fail;
12056 {
12057 PyThreadState* __tstate = wxPyBeginAllowThreads();
12058 result = (arg1)->GetGridLineColour();
12059
12060 wxPyEndAllowThreads(__tstate);
12061 if (PyErr_Occurred()) SWIG_fail;
12062 }
12063 {
12064 wxColour * resultptr;
12065 resultptr = new wxColour((wxColour &)(result));
12066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12067 }
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj;
12076 wxGrid *arg1 = (wxGrid *) 0 ;
12077 wxColour result;
12078 PyObject * obj0 = 0 ;
12079 char *kwnames[] = {
12080 (char *) "self", NULL
12081 };
12082
12083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12085 if (SWIG_arg_fail(1)) SWIG_fail;
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (arg1)->GetCellHighlightColour();
12089
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 {
12094 wxColour * resultptr;
12095 resultptr = new wxColour((wxColour &)(result));
12096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12097 }
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj;
12106 wxGrid *arg1 = (wxGrid *) 0 ;
12107 int result;
12108 PyObject * obj0 = 0 ;
12109 char *kwnames[] = {
12110 (char *) "self", NULL
12111 };
12112
12113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12115 if (SWIG_arg_fail(1)) SWIG_fail;
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (int)(arg1)->GetCellHighlightPenWidth();
12119
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 {
12124 resultobj = SWIG_From_int((int)(result));
12125 }
12126 return resultobj;
12127 fail:
12128 return NULL;
12129 }
12130
12131
12132 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12133 PyObject *resultobj;
12134 wxGrid *arg1 = (wxGrid *) 0 ;
12135 int result;
12136 PyObject * obj0 = 0 ;
12137 char *kwnames[] = {
12138 (char *) "self", NULL
12139 };
12140
12141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12143 if (SWIG_arg_fail(1)) SWIG_fail;
12144 {
12145 PyThreadState* __tstate = wxPyBeginAllowThreads();
12146 result = (int)(arg1)->GetCellHighlightROPenWidth();
12147
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 resultobj = SWIG_From_int((int)(result));
12153 }
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj;
12162 wxGrid *arg1 = (wxGrid *) 0 ;
12163 int arg2 ;
12164 PyObject * obj0 = 0 ;
12165 PyObject * obj1 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self",(char *) "width", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 arg2 = (int)(SWIG_As_int(obj1));
12175 if (SWIG_arg_fail(2)) SWIG_fail;
12176 }
12177 {
12178 PyThreadState* __tstate = wxPyBeginAllowThreads();
12179 (arg1)->SetRowLabelSize(arg2);
12180
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 Py_INCREF(Py_None); resultobj = Py_None;
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxGrid *arg1 = (wxGrid *) 0 ;
12194 int arg2 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self",(char *) "height", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12203 if (SWIG_arg_fail(1)) SWIG_fail;
12204 {
12205 arg2 = (int)(SWIG_As_int(obj1));
12206 if (SWIG_arg_fail(2)) SWIG_fail;
12207 }
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 (arg1)->SetColLabelSize(arg2);
12211
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 Py_INCREF(Py_None); resultobj = Py_None;
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12223 PyObject *resultobj;
12224 wxGrid *arg1 = (wxGrid *) 0 ;
12225 wxColour *arg2 = 0 ;
12226 wxColour temp2 ;
12227 PyObject * obj0 = 0 ;
12228 PyObject * obj1 = 0 ;
12229 char *kwnames[] = {
12230 (char *) "self","arg2", NULL
12231 };
12232
12233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12235 if (SWIG_arg_fail(1)) SWIG_fail;
12236 {
12237 arg2 = &temp2;
12238 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 Py_INCREF(Py_None); resultobj = Py_None;
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj;
12256 wxGrid *arg1 = (wxGrid *) 0 ;
12257 wxColour *arg2 = 0 ;
12258 wxColour temp2 ;
12259 PyObject * obj0 = 0 ;
12260 PyObject * obj1 = 0 ;
12261 char *kwnames[] = {
12262 (char *) "self","arg2", NULL
12263 };
12264
12265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) goto fail;
12266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12267 if (SWIG_arg_fail(1)) SWIG_fail;
12268 {
12269 arg2 = &temp2;
12270 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12271 }
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
12275
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 Py_INCREF(Py_None); resultobj = Py_None;
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 static PyObject *_wrap_Grid_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj;
12288 wxGrid *arg1 = (wxGrid *) 0 ;
12289 wxFont *arg2 = 0 ;
12290 PyObject * obj0 = 0 ;
12291 PyObject * obj1 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "self","arg2", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12298 if (SWIG_arg_fail(1)) SWIG_fail;
12299 {
12300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12301 if (SWIG_arg_fail(2)) SWIG_fail;
12302 if (arg2 == NULL) {
12303 SWIG_null_ref("wxFont");
12304 }
12305 if (SWIG_arg_fail(2)) SWIG_fail;
12306 }
12307 {
12308 PyThreadState* __tstate = wxPyBeginAllowThreads();
12309 (arg1)->SetLabelFont((wxFont const &)*arg2);
12310
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 Py_INCREF(Py_None); resultobj = Py_None;
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12322 PyObject *resultobj;
12323 wxGrid *arg1 = (wxGrid *) 0 ;
12324 int arg2 ;
12325 int arg3 ;
12326 PyObject * obj0 = 0 ;
12327 PyObject * obj1 = 0 ;
12328 PyObject * obj2 = 0 ;
12329 char *kwnames[] = {
12330 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12331 };
12332
12333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12335 if (SWIG_arg_fail(1)) SWIG_fail;
12336 {
12337 arg2 = (int)(SWIG_As_int(obj1));
12338 if (SWIG_arg_fail(2)) SWIG_fail;
12339 }
12340 {
12341 arg3 = (int)(SWIG_As_int(obj2));
12342 if (SWIG_arg_fail(3)) SWIG_fail;
12343 }
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 (arg1)->SetRowLabelAlignment(arg2,arg3);
12347
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 Py_INCREF(Py_None); resultobj = Py_None;
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj;
12360 wxGrid *arg1 = (wxGrid *) 0 ;
12361 int arg2 ;
12362 int arg3 ;
12363 PyObject * obj0 = 0 ;
12364 PyObject * obj1 = 0 ;
12365 PyObject * obj2 = 0 ;
12366 char *kwnames[] = {
12367 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12368 };
12369
12370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12372 if (SWIG_arg_fail(1)) SWIG_fail;
12373 {
12374 arg2 = (int)(SWIG_As_int(obj1));
12375 if (SWIG_arg_fail(2)) SWIG_fail;
12376 }
12377 {
12378 arg3 = (int)(SWIG_As_int(obj2));
12379 if (SWIG_arg_fail(3)) SWIG_fail;
12380 }
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 (arg1)->SetColLabelAlignment(arg2,arg3);
12384
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 Py_INCREF(Py_None); resultobj = Py_None;
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj;
12397 wxGrid *arg1 = (wxGrid *) 0 ;
12398 int arg2 ;
12399 PyObject * obj0 = 0 ;
12400 PyObject * obj1 = 0 ;
12401 char *kwnames[] = {
12402 (char *) "self",(char *) "textOrientation", NULL
12403 };
12404
12405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12407 if (SWIG_arg_fail(1)) SWIG_fail;
12408 {
12409 arg2 = (int)(SWIG_As_int(obj1));
12410 if (SWIG_arg_fail(2)) SWIG_fail;
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 (arg1)->SetColLabelTextOrientation(arg2);
12415
12416 wxPyEndAllowThreads(__tstate);
12417 if (PyErr_Occurred()) SWIG_fail;
12418 }
12419 Py_INCREF(Py_None); resultobj = Py_None;
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj;
12428 wxGrid *arg1 = (wxGrid *) 0 ;
12429 int arg2 ;
12430 wxString *arg3 = 0 ;
12431 bool temp3 = false ;
12432 PyObject * obj0 = 0 ;
12433 PyObject * obj1 = 0 ;
12434 PyObject * obj2 = 0 ;
12435 char *kwnames[] = {
12436 (char *) "self",(char *) "row","arg3", NULL
12437 };
12438
12439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12441 if (SWIG_arg_fail(1)) SWIG_fail;
12442 {
12443 arg2 = (int)(SWIG_As_int(obj1));
12444 if (SWIG_arg_fail(2)) SWIG_fail;
12445 }
12446 {
12447 arg3 = wxString_in_helper(obj2);
12448 if (arg3 == NULL) SWIG_fail;
12449 temp3 = true;
12450 }
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12454
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 Py_INCREF(Py_None); resultobj = Py_None;
12459 {
12460 if (temp3)
12461 delete arg3;
12462 }
12463 return resultobj;
12464 fail:
12465 {
12466 if (temp3)
12467 delete arg3;
12468 }
12469 return NULL;
12470 }
12471
12472
12473 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj;
12475 wxGrid *arg1 = (wxGrid *) 0 ;
12476 int arg2 ;
12477 wxString *arg3 = 0 ;
12478 bool temp3 = false ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 char *kwnames[] = {
12483 (char *) "self",(char *) "col","arg3", NULL
12484 };
12485
12486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12488 if (SWIG_arg_fail(1)) SWIG_fail;
12489 {
12490 arg2 = (int)(SWIG_As_int(obj1));
12491 if (SWIG_arg_fail(2)) SWIG_fail;
12492 }
12493 {
12494 arg3 = wxString_in_helper(obj2);
12495 if (arg3 == NULL) SWIG_fail;
12496 temp3 = true;
12497 }
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 Py_INCREF(Py_None); resultobj = Py_None;
12506 {
12507 if (temp3)
12508 delete arg3;
12509 }
12510 return resultobj;
12511 fail:
12512 {
12513 if (temp3)
12514 delete arg3;
12515 }
12516 return NULL;
12517 }
12518
12519
12520 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj;
12522 wxGrid *arg1 = (wxGrid *) 0 ;
12523 wxColour *arg2 = 0 ;
12524 wxColour temp2 ;
12525 PyObject * obj0 = 0 ;
12526 PyObject * obj1 = 0 ;
12527 char *kwnames[] = {
12528 (char *) "self","arg2", NULL
12529 };
12530
12531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12533 if (SWIG_arg_fail(1)) SWIG_fail;
12534 {
12535 arg2 = &temp2;
12536 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12537 }
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 Py_INCREF(Py_None); resultobj = Py_None;
12546 return resultobj;
12547 fail:
12548 return NULL;
12549 }
12550
12551
12552 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj;
12554 wxGrid *arg1 = (wxGrid *) 0 ;
12555 wxColour *arg2 = 0 ;
12556 wxColour temp2 ;
12557 PyObject * obj0 = 0 ;
12558 PyObject * obj1 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self","arg2", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 arg2 = &temp2;
12568 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12569 }
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
12573
12574 wxPyEndAllowThreads(__tstate);
12575 if (PyErr_Occurred()) SWIG_fail;
12576 }
12577 Py_INCREF(Py_None); resultobj = Py_None;
12578 return resultobj;
12579 fail:
12580 return NULL;
12581 }
12582
12583
12584 static PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj;
12586 wxGrid *arg1 = (wxGrid *) 0 ;
12587 int arg2 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 char *kwnames[] = {
12591 (char *) "self",(char *) "width", NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12596 if (SWIG_arg_fail(1)) SWIG_fail;
12597 {
12598 arg2 = (int)(SWIG_As_int(obj1));
12599 if (SWIG_arg_fail(2)) SWIG_fail;
12600 }
12601 {
12602 PyThreadState* __tstate = wxPyBeginAllowThreads();
12603 (arg1)->SetCellHighlightPenWidth(arg2);
12604
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 Py_INCREF(Py_None); resultobj = Py_None;
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12616 PyObject *resultobj;
12617 wxGrid *arg1 = (wxGrid *) 0 ;
12618 int arg2 ;
12619 PyObject * obj0 = 0 ;
12620 PyObject * obj1 = 0 ;
12621 char *kwnames[] = {
12622 (char *) "self",(char *) "width", NULL
12623 };
12624
12625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12627 if (SWIG_arg_fail(1)) SWIG_fail;
12628 {
12629 arg2 = (int)(SWIG_As_int(obj1));
12630 if (SWIG_arg_fail(2)) SWIG_fail;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 (arg1)->SetCellHighlightROPenWidth(arg2);
12635
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 Py_INCREF(Py_None); resultobj = Py_None;
12640 return resultobj;
12641 fail:
12642 return NULL;
12643 }
12644
12645
12646 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj;
12648 wxGrid *arg1 = (wxGrid *) 0 ;
12649 bool arg2 = (bool) true ;
12650 PyObject * obj0 = 0 ;
12651 PyObject * obj1 = 0 ;
12652 char *kwnames[] = {
12653 (char *) "self",(char *) "enable", NULL
12654 };
12655
12656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(1)) SWIG_fail;
12659 if (obj1) {
12660 {
12661 arg2 = (bool)(SWIG_As_bool(obj1));
12662 if (SWIG_arg_fail(2)) SWIG_fail;
12663 }
12664 }
12665 {
12666 PyThreadState* __tstate = wxPyBeginAllowThreads();
12667 (arg1)->EnableDragRowSize(arg2);
12668
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 Py_INCREF(Py_None); resultobj = Py_None;
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_Grid_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxGrid *arg1 = (wxGrid *) 0 ;
12682 PyObject * obj0 = 0 ;
12683 char *kwnames[] = {
12684 (char *) "self", NULL
12685 };
12686
12687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12689 if (SWIG_arg_fail(1)) SWIG_fail;
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 (arg1)->DisableDragRowSize();
12693
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 Py_INCREF(Py_None); resultobj = Py_None;
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxGrid *arg1 = (wxGrid *) 0 ;
12707 bool result;
12708 PyObject * obj0 = 0 ;
12709 char *kwnames[] = {
12710 (char *) "self", NULL
12711 };
12712
12713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12715 if (SWIG_arg_fail(1)) SWIG_fail;
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 result = (bool)(arg1)->CanDragRowSize();
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 {
12724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12725 }
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12733 PyObject *resultobj;
12734 wxGrid *arg1 = (wxGrid *) 0 ;
12735 bool arg2 = (bool) true ;
12736 PyObject * obj0 = 0 ;
12737 PyObject * obj1 = 0 ;
12738 char *kwnames[] = {
12739 (char *) "self",(char *) "enable", NULL
12740 };
12741
12742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12744 if (SWIG_arg_fail(1)) SWIG_fail;
12745 if (obj1) {
12746 {
12747 arg2 = (bool)(SWIG_As_bool(obj1));
12748 if (SWIG_arg_fail(2)) SWIG_fail;
12749 }
12750 }
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 (arg1)->EnableDragColSize(arg2);
12754
12755 wxPyEndAllowThreads(__tstate);
12756 if (PyErr_Occurred()) SWIG_fail;
12757 }
12758 Py_INCREF(Py_None); resultobj = Py_None;
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj;
12767 wxGrid *arg1 = (wxGrid *) 0 ;
12768 PyObject * obj0 = 0 ;
12769 char *kwnames[] = {
12770 (char *) "self", NULL
12771 };
12772
12773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12775 if (SWIG_arg_fail(1)) SWIG_fail;
12776 {
12777 PyThreadState* __tstate = wxPyBeginAllowThreads();
12778 (arg1)->DisableDragColSize();
12779
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 Py_INCREF(Py_None); resultobj = Py_None;
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj;
12792 wxGrid *arg1 = (wxGrid *) 0 ;
12793 bool result;
12794 PyObject * obj0 = 0 ;
12795 char *kwnames[] = {
12796 (char *) "self", NULL
12797 };
12798
12799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
12800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12801 if (SWIG_arg_fail(1)) SWIG_fail;
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (bool)(arg1)->CanDragColSize();
12805
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 {
12810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12811 }
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12819 PyObject *resultobj;
12820 wxGrid *arg1 = (wxGrid *) 0 ;
12821 bool arg2 = (bool) true ;
12822 PyObject * obj0 = 0 ;
12823 PyObject * obj1 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "enable", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 if (obj1) {
12832 {
12833 arg2 = (bool)(SWIG_As_bool(obj1));
12834 if (SWIG_arg_fail(2)) SWIG_fail;
12835 }
12836 }
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 (arg1)->EnableDragGridSize(arg2);
12840
12841 wxPyEndAllowThreads(__tstate);
12842 if (PyErr_Occurred()) SWIG_fail;
12843 }
12844 Py_INCREF(Py_None); resultobj = Py_None;
12845 return resultobj;
12846 fail:
12847 return NULL;
12848 }
12849
12850
12851 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj;
12853 wxGrid *arg1 = (wxGrid *) 0 ;
12854 PyObject * obj0 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 (arg1)->DisableDragGridSize();
12865
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 Py_INCREF(Py_None); resultobj = Py_None;
12870 return resultobj;
12871 fail:
12872 return NULL;
12873 }
12874
12875
12876 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12877 PyObject *resultobj;
12878 wxGrid *arg1 = (wxGrid *) 0 ;
12879 bool result;
12880 PyObject * obj0 = 0 ;
12881 char *kwnames[] = {
12882 (char *) "self", NULL
12883 };
12884
12885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
12886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12887 if (SWIG_arg_fail(1)) SWIG_fail;
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 result = (bool)(arg1)->CanDragGridSize();
12891
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 {
12896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12897 }
12898 return resultobj;
12899 fail:
12900 return NULL;
12901 }
12902
12903
12904 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12905 PyObject *resultobj;
12906 wxGrid *arg1 = (wxGrid *) 0 ;
12907 bool arg2 = (bool) true ;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12910 char *kwnames[] = {
12911 (char *) "self",(char *) "enable", NULL
12912 };
12913
12914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
12915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12916 if (SWIG_arg_fail(1)) SWIG_fail;
12917 if (obj1) {
12918 {
12919 arg2 = (bool)(SWIG_As_bool(obj1));
12920 if (SWIG_arg_fail(2)) SWIG_fail;
12921 }
12922 }
12923 {
12924 PyThreadState* __tstate = wxPyBeginAllowThreads();
12925 (arg1)->EnableDragCell(arg2);
12926
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 Py_INCREF(Py_None); resultobj = Py_None;
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12938 PyObject *resultobj;
12939 wxGrid *arg1 = (wxGrid *) 0 ;
12940 PyObject * obj0 = 0 ;
12941 char *kwnames[] = {
12942 (char *) "self", NULL
12943 };
12944
12945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
12946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12947 if (SWIG_arg_fail(1)) SWIG_fail;
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 (arg1)->DisableDragCell();
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 Py_INCREF(Py_None); resultobj = Py_None;
12956 return resultobj;
12957 fail:
12958 return NULL;
12959 }
12960
12961
12962 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12963 PyObject *resultobj;
12964 wxGrid *arg1 = (wxGrid *) 0 ;
12965 bool result;
12966 PyObject * obj0 = 0 ;
12967 char *kwnames[] = {
12968 (char *) "self", NULL
12969 };
12970
12971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
12972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12973 if (SWIG_arg_fail(1)) SWIG_fail;
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = (bool)(arg1)->CanDragCell();
12977
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 {
12982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12983 }
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj;
12992 wxGrid *arg1 = (wxGrid *) 0 ;
12993 int arg2 ;
12994 int arg3 ;
12995 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
12996 PyObject * obj0 = 0 ;
12997 PyObject * obj1 = 0 ;
12998 PyObject * obj2 = 0 ;
12999 PyObject * obj3 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 {
13008 arg2 = (int)(SWIG_As_int(obj1));
13009 if (SWIG_arg_fail(2)) SWIG_fail;
13010 }
13011 {
13012 arg3 = (int)(SWIG_As_int(obj2));
13013 if (SWIG_arg_fail(3)) SWIG_fail;
13014 }
13015 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13016 if (SWIG_arg_fail(4)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 (arg1)->SetAttr(arg2,arg3,arg4);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 Py_INCREF(Py_None); resultobj = Py_None;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxGrid *arg1 = (wxGrid *) 0 ;
13034 int arg2 ;
13035 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 PyObject * obj2 = 0 ;
13039 char *kwnames[] = {
13040 (char *) "self",(char *) "row",(char *) "attr", NULL
13041 };
13042
13043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13045 if (SWIG_arg_fail(1)) SWIG_fail;
13046 {
13047 arg2 = (int)(SWIG_As_int(obj1));
13048 if (SWIG_arg_fail(2)) SWIG_fail;
13049 }
13050 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13051 if (SWIG_arg_fail(3)) SWIG_fail;
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 (arg1)->SetRowAttr(arg2,arg3);
13055
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 Py_INCREF(Py_None); resultobj = Py_None;
13060 return resultobj;
13061 fail:
13062 return NULL;
13063 }
13064
13065
13066 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13067 PyObject *resultobj;
13068 wxGrid *arg1 = (wxGrid *) 0 ;
13069 int arg2 ;
13070 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 PyObject * obj2 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "col",(char *) "attr", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = (int)(SWIG_As_int(obj1));
13083 if (SWIG_arg_fail(2)) SWIG_fail;
13084 }
13085 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13086 if (SWIG_arg_fail(3)) SWIG_fail;
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->SetColAttr(arg2,arg3);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 Py_INCREF(Py_None); resultobj = Py_None;
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxGrid *arg1 = (wxGrid *) 0 ;
13104 int arg2 ;
13105 int arg3 ;
13106 wxGridCellAttr *result;
13107 PyObject * obj0 = 0 ;
13108 PyObject * obj1 = 0 ;
13109 PyObject * obj2 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "row",(char *) "col", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 {
13118 arg2 = (int)(SWIG_As_int(obj1));
13119 if (SWIG_arg_fail(2)) SWIG_fail;
13120 }
13121 {
13122 arg3 = (int)(SWIG_As_int(obj2));
13123 if (SWIG_arg_fail(3)) SWIG_fail;
13124 }
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13128
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 {
13133 resultobj = wxPyMake_wxGridCellAttr(result, 0);
13134 }
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj;
13143 wxGrid *arg1 = (wxGrid *) 0 ;
13144 int arg2 ;
13145 PyObject * obj0 = 0 ;
13146 PyObject * obj1 = 0 ;
13147 char *kwnames[] = {
13148 (char *) "self",(char *) "col", NULL
13149 };
13150
13151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13153 if (SWIG_arg_fail(1)) SWIG_fail;
13154 {
13155 arg2 = (int)(SWIG_As_int(obj1));
13156 if (SWIG_arg_fail(2)) SWIG_fail;
13157 }
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 (arg1)->SetColFormatBool(arg2);
13161
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 Py_INCREF(Py_None); resultobj = Py_None;
13166 return resultobj;
13167 fail:
13168 return NULL;
13169 }
13170
13171
13172 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13173 PyObject *resultobj;
13174 wxGrid *arg1 = (wxGrid *) 0 ;
13175 int arg2 ;
13176 PyObject * obj0 = 0 ;
13177 PyObject * obj1 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "self",(char *) "col", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 arg2 = (int)(SWIG_As_int(obj1));
13187 if (SWIG_arg_fail(2)) SWIG_fail;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 (arg1)->SetColFormatNumber(arg2);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 Py_INCREF(Py_None); resultobj = Py_None;
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj;
13205 wxGrid *arg1 = (wxGrid *) 0 ;
13206 int arg2 ;
13207 int arg3 = (int) -1 ;
13208 int arg4 = (int) -1 ;
13209 PyObject * obj0 = 0 ;
13210 PyObject * obj1 = 0 ;
13211 PyObject * obj2 = 0 ;
13212 PyObject * obj3 = 0 ;
13213 char *kwnames[] = {
13214 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13215 };
13216
13217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13219 if (SWIG_arg_fail(1)) SWIG_fail;
13220 {
13221 arg2 = (int)(SWIG_As_int(obj1));
13222 if (SWIG_arg_fail(2)) SWIG_fail;
13223 }
13224 if (obj2) {
13225 {
13226 arg3 = (int)(SWIG_As_int(obj2));
13227 if (SWIG_arg_fail(3)) SWIG_fail;
13228 }
13229 }
13230 if (obj3) {
13231 {
13232 arg4 = (int)(SWIG_As_int(obj3));
13233 if (SWIG_arg_fail(4)) SWIG_fail;
13234 }
13235 }
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13239
13240 wxPyEndAllowThreads(__tstate);
13241 if (PyErr_Occurred()) SWIG_fail;
13242 }
13243 Py_INCREF(Py_None); resultobj = Py_None;
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxGrid *arg1 = (wxGrid *) 0 ;
13253 int arg2 ;
13254 wxString *arg3 = 0 ;
13255 bool temp3 = false ;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 PyObject * obj2 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self",(char *) "col",(char *) "typeName", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 arg2 = (int)(SWIG_As_int(obj1));
13268 if (SWIG_arg_fail(2)) SWIG_fail;
13269 }
13270 {
13271 arg3 = wxString_in_helper(obj2);
13272 if (arg3 == NULL) SWIG_fail;
13273 temp3 = true;
13274 }
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 Py_INCREF(Py_None); resultobj = Py_None;
13283 {
13284 if (temp3)
13285 delete arg3;
13286 }
13287 return resultobj;
13288 fail:
13289 {
13290 if (temp3)
13291 delete arg3;
13292 }
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxGrid *arg1 = (wxGrid *) 0 ;
13300 bool arg2 = (bool) true ;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13303 char *kwnames[] = {
13304 (char *) "self",(char *) "enable", NULL
13305 };
13306
13307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13309 if (SWIG_arg_fail(1)) SWIG_fail;
13310 if (obj1) {
13311 {
13312 arg2 = (bool)(SWIG_As_bool(obj1));
13313 if (SWIG_arg_fail(2)) SWIG_fail;
13314 }
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 (arg1)->EnableGridLines(arg2);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 Py_INCREF(Py_None); resultobj = Py_None;
13324 return resultobj;
13325 fail:
13326 return NULL;
13327 }
13328
13329
13330 static PyObject *_wrap_Grid_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxGrid *arg1 = (wxGrid *) 0 ;
13333 bool result;
13334 PyObject * obj0 = 0 ;
13335 char *kwnames[] = {
13336 (char *) "self", NULL
13337 };
13338
13339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13341 if (SWIG_arg_fail(1)) SWIG_fail;
13342 {
13343 PyThreadState* __tstate = wxPyBeginAllowThreads();
13344 result = (bool)(arg1)->GridLinesEnabled();
13345
13346 wxPyEndAllowThreads(__tstate);
13347 if (PyErr_Occurred()) SWIG_fail;
13348 }
13349 {
13350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13351 }
13352 return resultobj;
13353 fail:
13354 return NULL;
13355 }
13356
13357
13358 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13359 PyObject *resultobj;
13360 wxGrid *arg1 = (wxGrid *) 0 ;
13361 int result;
13362 PyObject * obj0 = 0 ;
13363 char *kwnames[] = {
13364 (char *) "self", NULL
13365 };
13366
13367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13369 if (SWIG_arg_fail(1)) SWIG_fail;
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 result = (int)(arg1)->GetDefaultRowSize();
13373
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 {
13378 resultobj = SWIG_From_int((int)(result));
13379 }
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13387 PyObject *resultobj;
13388 wxGrid *arg1 = (wxGrid *) 0 ;
13389 int arg2 ;
13390 int result;
13391 PyObject * obj0 = 0 ;
13392 PyObject * obj1 = 0 ;
13393 char *kwnames[] = {
13394 (char *) "self",(char *) "row", NULL
13395 };
13396
13397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13399 if (SWIG_arg_fail(1)) SWIG_fail;
13400 {
13401 arg2 = (int)(SWIG_As_int(obj1));
13402 if (SWIG_arg_fail(2)) SWIG_fail;
13403 }
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 result = (int)(arg1)->GetRowSize(arg2);
13407
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 {
13412 resultobj = SWIG_From_int((int)(result));
13413 }
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13421 PyObject *resultobj;
13422 wxGrid *arg1 = (wxGrid *) 0 ;
13423 int result;
13424 PyObject * obj0 = 0 ;
13425 char *kwnames[] = {
13426 (char *) "self", NULL
13427 };
13428
13429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13431 if (SWIG_arg_fail(1)) SWIG_fail;
13432 {
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (int)(arg1)->GetDefaultColSize();
13435
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 {
13440 resultobj = SWIG_From_int((int)(result));
13441 }
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj;
13450 wxGrid *arg1 = (wxGrid *) 0 ;
13451 int arg2 ;
13452 int result;
13453 PyObject * obj0 = 0 ;
13454 PyObject * obj1 = 0 ;
13455 char *kwnames[] = {
13456 (char *) "self",(char *) "col", NULL
13457 };
13458
13459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13461 if (SWIG_arg_fail(1)) SWIG_fail;
13462 {
13463 arg2 = (int)(SWIG_As_int(obj1));
13464 if (SWIG_arg_fail(2)) SWIG_fail;
13465 }
13466 {
13467 PyThreadState* __tstate = wxPyBeginAllowThreads();
13468 result = (int)(arg1)->GetColSize(arg2);
13469
13470 wxPyEndAllowThreads(__tstate);
13471 if (PyErr_Occurred()) SWIG_fail;
13472 }
13473 {
13474 resultobj = SWIG_From_int((int)(result));
13475 }
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj;
13484 wxGrid *arg1 = (wxGrid *) 0 ;
13485 wxColour result;
13486 PyObject * obj0 = 0 ;
13487 char *kwnames[] = {
13488 (char *) "self", NULL
13489 };
13490
13491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13493 if (SWIG_arg_fail(1)) SWIG_fail;
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = (arg1)->GetDefaultCellBackgroundColour();
13497
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 {
13502 wxColour * resultptr;
13503 resultptr = new wxColour((wxColour &)(result));
13504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13505 }
13506 return resultobj;
13507 fail:
13508 return NULL;
13509 }
13510
13511
13512 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxGrid *arg1 = (wxGrid *) 0 ;
13515 int arg2 ;
13516 int arg3 ;
13517 wxColour result;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 PyObject * obj2 = 0 ;
13521 char *kwnames[] = {
13522 (char *) "self",(char *) "row",(char *) "col", NULL
13523 };
13524
13525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13527 if (SWIG_arg_fail(1)) SWIG_fail;
13528 {
13529 arg2 = (int)(SWIG_As_int(obj1));
13530 if (SWIG_arg_fail(2)) SWIG_fail;
13531 }
13532 {
13533 arg3 = (int)(SWIG_As_int(obj2));
13534 if (SWIG_arg_fail(3)) SWIG_fail;
13535 }
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 wxColour * resultptr;
13545 resultptr = new wxColour((wxColour &)(result));
13546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13547 }
13548 return resultobj;
13549 fail:
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxGrid *arg1 = (wxGrid *) 0 ;
13557 wxColour result;
13558 PyObject * obj0 = 0 ;
13559 char *kwnames[] = {
13560 (char *) "self", NULL
13561 };
13562
13563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13565 if (SWIG_arg_fail(1)) SWIG_fail;
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (arg1)->GetDefaultCellTextColour();
13569
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 {
13574 wxColour * resultptr;
13575 resultptr = new wxColour((wxColour &)(result));
13576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13577 }
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 wxGrid *arg1 = (wxGrid *) 0 ;
13587 int arg2 ;
13588 int arg3 ;
13589 wxColour result;
13590 PyObject * obj0 = 0 ;
13591 PyObject * obj1 = 0 ;
13592 PyObject * obj2 = 0 ;
13593 char *kwnames[] = {
13594 (char *) "self",(char *) "row",(char *) "col", NULL
13595 };
13596
13597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13599 if (SWIG_arg_fail(1)) SWIG_fail;
13600 {
13601 arg2 = (int)(SWIG_As_int(obj1));
13602 if (SWIG_arg_fail(2)) SWIG_fail;
13603 }
13604 {
13605 arg3 = (int)(SWIG_As_int(obj2));
13606 if (SWIG_arg_fail(3)) SWIG_fail;
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (arg1)->GetCellTextColour(arg2,arg3);
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 {
13616 wxColour * resultptr;
13617 resultptr = new wxColour((wxColour &)(result));
13618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13619 }
13620 return resultobj;
13621 fail:
13622 return NULL;
13623 }
13624
13625
13626 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 wxGrid *arg1 = (wxGrid *) 0 ;
13629 wxFont result;
13630 PyObject * obj0 = 0 ;
13631 char *kwnames[] = {
13632 (char *) "self", NULL
13633 };
13634
13635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13637 if (SWIG_arg_fail(1)) SWIG_fail;
13638 {
13639 PyThreadState* __tstate = wxPyBeginAllowThreads();
13640 result = (arg1)->GetDefaultCellFont();
13641
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 {
13646 wxFont * resultptr;
13647 resultptr = new wxFont((wxFont &)(result));
13648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13649 }
13650 return resultobj;
13651 fail:
13652 return NULL;
13653 }
13654
13655
13656 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj;
13658 wxGrid *arg1 = (wxGrid *) 0 ;
13659 int arg2 ;
13660 int arg3 ;
13661 wxFont result;
13662 PyObject * obj0 = 0 ;
13663 PyObject * obj1 = 0 ;
13664 PyObject * obj2 = 0 ;
13665 char *kwnames[] = {
13666 (char *) "self",(char *) "row",(char *) "col", NULL
13667 };
13668
13669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13671 if (SWIG_arg_fail(1)) SWIG_fail;
13672 {
13673 arg2 = (int)(SWIG_As_int(obj1));
13674 if (SWIG_arg_fail(2)) SWIG_fail;
13675 }
13676 {
13677 arg3 = (int)(SWIG_As_int(obj2));
13678 if (SWIG_arg_fail(3)) SWIG_fail;
13679 }
13680 {
13681 PyThreadState* __tstate = wxPyBeginAllowThreads();
13682 result = (arg1)->GetCellFont(arg2,arg3);
13683
13684 wxPyEndAllowThreads(__tstate);
13685 if (PyErr_Occurred()) SWIG_fail;
13686 }
13687 {
13688 wxFont * resultptr;
13689 resultptr = new wxFont((wxFont &)(result));
13690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13691 }
13692 return resultobj;
13693 fail:
13694 return NULL;
13695 }
13696
13697
13698 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj;
13700 wxGrid *arg1 = (wxGrid *) 0 ;
13701 int *arg2 = (int *) 0 ;
13702 int *arg3 = (int *) 0 ;
13703 int temp2 ;
13704 int res2 = 0 ;
13705 int temp3 ;
13706 int res3 = 0 ;
13707 PyObject * obj0 = 0 ;
13708 char *kwnames[] = {
13709 (char *) "self", NULL
13710 };
13711
13712 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13713 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13716 if (SWIG_arg_fail(1)) SWIG_fail;
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13720
13721 wxPyEndAllowThreads(__tstate);
13722 if (PyErr_Occurred()) SWIG_fail;
13723 }
13724 Py_INCREF(Py_None); resultobj = Py_None;
13725 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13726 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13727 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13728 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxGrid *arg1 = (wxGrid *) 0 ;
13738 int arg2 ;
13739 int arg3 ;
13740 int *arg4 = (int *) 0 ;
13741 int *arg5 = (int *) 0 ;
13742 int temp4 ;
13743 int res4 = 0 ;
13744 int temp5 ;
13745 int res5 = 0 ;
13746 PyObject * obj0 = 0 ;
13747 PyObject * obj1 = 0 ;
13748 PyObject * obj2 = 0 ;
13749 char *kwnames[] = {
13750 (char *) "self",(char *) "row",(char *) "col", NULL
13751 };
13752
13753 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13754 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
13756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13757 if (SWIG_arg_fail(1)) SWIG_fail;
13758 {
13759 arg2 = (int)(SWIG_As_int(obj1));
13760 if (SWIG_arg_fail(2)) SWIG_fail;
13761 }
13762 {
13763 arg3 = (int)(SWIG_As_int(obj2));
13764 if (SWIG_arg_fail(3)) SWIG_fail;
13765 }
13766 {
13767 PyThreadState* __tstate = wxPyBeginAllowThreads();
13768 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13769
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 Py_INCREF(Py_None); resultobj = Py_None;
13774 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13775 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13776 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13777 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13778 return resultobj;
13779 fail:
13780 return NULL;
13781 }
13782
13783
13784 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13785 PyObject *resultobj;
13786 wxGrid *arg1 = (wxGrid *) 0 ;
13787 bool result;
13788 PyObject * obj0 = 0 ;
13789 char *kwnames[] = {
13790 (char *) "self", NULL
13791 };
13792
13793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",kwnames,&obj0)) goto fail;
13794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13795 if (SWIG_arg_fail(1)) SWIG_fail;
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 result = (bool)(arg1)->GetDefaultCellOverflow();
13799
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 {
13804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13805 }
13806 return resultobj;
13807 fail:
13808 return NULL;
13809 }
13810
13811
13812 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj;
13814 wxGrid *arg1 = (wxGrid *) 0 ;
13815 int arg2 ;
13816 int arg3 ;
13817 bool result;
13818 PyObject * obj0 = 0 ;
13819 PyObject * obj1 = 0 ;
13820 PyObject * obj2 = 0 ;
13821 char *kwnames[] = {
13822 (char *) "self",(char *) "row",(char *) "col", NULL
13823 };
13824
13825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
13826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13827 if (SWIG_arg_fail(1)) SWIG_fail;
13828 {
13829 arg2 = (int)(SWIG_As_int(obj1));
13830 if (SWIG_arg_fail(2)) SWIG_fail;
13831 }
13832 {
13833 arg3 = (int)(SWIG_As_int(obj2));
13834 if (SWIG_arg_fail(3)) SWIG_fail;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 {
13844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13845 }
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj;
13854 wxGrid *arg1 = (wxGrid *) 0 ;
13855 int arg2 ;
13856 int arg3 ;
13857 int *arg4 = (int *) 0 ;
13858 int *arg5 = (int *) 0 ;
13859 int temp4 ;
13860 int res4 = 0 ;
13861 int temp5 ;
13862 int res5 = 0 ;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 char *kwnames[] = {
13867 (char *) "self",(char *) "row",(char *) "col", NULL
13868 };
13869
13870 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13871 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13874 if (SWIG_arg_fail(1)) SWIG_fail;
13875 {
13876 arg2 = (int)(SWIG_As_int(obj1));
13877 if (SWIG_arg_fail(2)) SWIG_fail;
13878 }
13879 {
13880 arg3 = (int)(SWIG_As_int(obj2));
13881 if (SWIG_arg_fail(3)) SWIG_fail;
13882 }
13883 {
13884 PyThreadState* __tstate = wxPyBeginAllowThreads();
13885 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
13886
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 Py_INCREF(Py_None); resultobj = Py_None;
13891 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13892 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13893 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13894 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj;
13903 wxGrid *arg1 = (wxGrid *) 0 ;
13904 int arg2 ;
13905 bool arg3 = (bool) false ;
13906 PyObject * obj0 = 0 ;
13907 PyObject * obj1 = 0 ;
13908 PyObject * obj2 = 0 ;
13909 char *kwnames[] = {
13910 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
13911 };
13912
13913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13915 if (SWIG_arg_fail(1)) SWIG_fail;
13916 {
13917 arg2 = (int)(SWIG_As_int(obj1));
13918 if (SWIG_arg_fail(2)) SWIG_fail;
13919 }
13920 if (obj2) {
13921 {
13922 arg3 = (bool)(SWIG_As_bool(obj2));
13923 if (SWIG_arg_fail(3)) SWIG_fail;
13924 }
13925 }
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 (arg1)->SetDefaultRowSize(arg2,arg3);
13929
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 Py_INCREF(Py_None); resultobj = Py_None;
13934 return resultobj;
13935 fail:
13936 return NULL;
13937 }
13938
13939
13940 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13941 PyObject *resultobj;
13942 wxGrid *arg1 = (wxGrid *) 0 ;
13943 int arg2 ;
13944 int arg3 ;
13945 PyObject * obj0 = 0 ;
13946 PyObject * obj1 = 0 ;
13947 PyObject * obj2 = 0 ;
13948 char *kwnames[] = {
13949 (char *) "self",(char *) "row",(char *) "height", NULL
13950 };
13951
13952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13954 if (SWIG_arg_fail(1)) SWIG_fail;
13955 {
13956 arg2 = (int)(SWIG_As_int(obj1));
13957 if (SWIG_arg_fail(2)) SWIG_fail;
13958 }
13959 {
13960 arg3 = (int)(SWIG_As_int(obj2));
13961 if (SWIG_arg_fail(3)) SWIG_fail;
13962 }
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 (arg1)->SetRowSize(arg2,arg3);
13966
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 Py_INCREF(Py_None); resultobj = Py_None;
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj;
13979 wxGrid *arg1 = (wxGrid *) 0 ;
13980 int arg2 ;
13981 bool arg3 = (bool) false ;
13982 PyObject * obj0 = 0 ;
13983 PyObject * obj1 = 0 ;
13984 PyObject * obj2 = 0 ;
13985 char *kwnames[] = {
13986 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
13987 };
13988
13989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13991 if (SWIG_arg_fail(1)) SWIG_fail;
13992 {
13993 arg2 = (int)(SWIG_As_int(obj1));
13994 if (SWIG_arg_fail(2)) SWIG_fail;
13995 }
13996 if (obj2) {
13997 {
13998 arg3 = (bool)(SWIG_As_bool(obj2));
13999 if (SWIG_arg_fail(3)) SWIG_fail;
14000 }
14001 }
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 (arg1)->SetDefaultColSize(arg2,arg3);
14005
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 Py_INCREF(Py_None); resultobj = Py_None;
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14017 PyObject *resultobj;
14018 wxGrid *arg1 = (wxGrid *) 0 ;
14019 int arg2 ;
14020 int arg3 ;
14021 PyObject * obj0 = 0 ;
14022 PyObject * obj1 = 0 ;
14023 PyObject * obj2 = 0 ;
14024 char *kwnames[] = {
14025 (char *) "self",(char *) "col",(char *) "width", NULL
14026 };
14027
14028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14030 if (SWIG_arg_fail(1)) SWIG_fail;
14031 {
14032 arg2 = (int)(SWIG_As_int(obj1));
14033 if (SWIG_arg_fail(2)) SWIG_fail;
14034 }
14035 {
14036 arg3 = (int)(SWIG_As_int(obj2));
14037 if (SWIG_arg_fail(3)) SWIG_fail;
14038 }
14039 {
14040 PyThreadState* __tstate = wxPyBeginAllowThreads();
14041 (arg1)->SetColSize(arg2,arg3);
14042
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 Py_INCREF(Py_None); resultobj = Py_None;
14047 return resultobj;
14048 fail:
14049 return NULL;
14050 }
14051
14052
14053 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14054 PyObject *resultobj;
14055 wxGrid *arg1 = (wxGrid *) 0 ;
14056 int arg2 ;
14057 bool arg3 = (bool) true ;
14058 PyObject * obj0 = 0 ;
14059 PyObject * obj1 = 0 ;
14060 PyObject * obj2 = 0 ;
14061 char *kwnames[] = {
14062 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14063 };
14064
14065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14067 if (SWIG_arg_fail(1)) SWIG_fail;
14068 {
14069 arg2 = (int)(SWIG_As_int(obj1));
14070 if (SWIG_arg_fail(2)) SWIG_fail;
14071 }
14072 if (obj2) {
14073 {
14074 arg3 = (bool)(SWIG_As_bool(obj2));
14075 if (SWIG_arg_fail(3)) SWIG_fail;
14076 }
14077 }
14078 {
14079 PyThreadState* __tstate = wxPyBeginAllowThreads();
14080 (arg1)->AutoSizeColumn(arg2,arg3);
14081
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 Py_INCREF(Py_None); resultobj = Py_None;
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14093 PyObject *resultobj;
14094 wxGrid *arg1 = (wxGrid *) 0 ;
14095 int arg2 ;
14096 bool arg3 = (bool) true ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 char *kwnames[] = {
14101 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14102 };
14103
14104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14106 if (SWIG_arg_fail(1)) SWIG_fail;
14107 {
14108 arg2 = (int)(SWIG_As_int(obj1));
14109 if (SWIG_arg_fail(2)) SWIG_fail;
14110 }
14111 if (obj2) {
14112 {
14113 arg3 = (bool)(SWIG_As_bool(obj2));
14114 if (SWIG_arg_fail(3)) SWIG_fail;
14115 }
14116 }
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 (arg1)->AutoSizeRow(arg2,arg3);
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 Py_INCREF(Py_None); resultobj = Py_None;
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj;
14133 wxGrid *arg1 = (wxGrid *) 0 ;
14134 bool arg2 = (bool) true ;
14135 PyObject * obj0 = 0 ;
14136 PyObject * obj1 = 0 ;
14137 char *kwnames[] = {
14138 (char *) "self",(char *) "setAsMin", NULL
14139 };
14140
14141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14143 if (SWIG_arg_fail(1)) SWIG_fail;
14144 if (obj1) {
14145 {
14146 arg2 = (bool)(SWIG_As_bool(obj1));
14147 if (SWIG_arg_fail(2)) SWIG_fail;
14148 }
14149 }
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 (arg1)->AutoSizeColumns(arg2);
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 Py_INCREF(Py_None); resultobj = Py_None;
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14165 PyObject *resultobj;
14166 wxGrid *arg1 = (wxGrid *) 0 ;
14167 bool arg2 = (bool) true ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 char *kwnames[] = {
14171 (char *) "self",(char *) "setAsMin", NULL
14172 };
14173
14174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14176 if (SWIG_arg_fail(1)) SWIG_fail;
14177 if (obj1) {
14178 {
14179 arg2 = (bool)(SWIG_As_bool(obj1));
14180 if (SWIG_arg_fail(2)) SWIG_fail;
14181 }
14182 }
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 (arg1)->AutoSizeRows(arg2);
14186
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 Py_INCREF(Py_None); resultobj = Py_None;
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj;
14199 wxGrid *arg1 = (wxGrid *) 0 ;
14200 PyObject * obj0 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 (arg1)->AutoSize();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 Py_INCREF(Py_None); resultobj = Py_None;
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj;
14224 wxGrid *arg1 = (wxGrid *) 0 ;
14225 int arg2 ;
14226 PyObject * obj0 = 0 ;
14227 PyObject * obj1 = 0 ;
14228 char *kwnames[] = {
14229 (char *) "self",(char *) "row", NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14234 if (SWIG_arg_fail(1)) SWIG_fail;
14235 {
14236 arg2 = (int)(SWIG_As_int(obj1));
14237 if (SWIG_arg_fail(2)) SWIG_fail;
14238 }
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 (arg1)->AutoSizeRowLabelSize(arg2);
14242
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 Py_INCREF(Py_None); resultobj = Py_None;
14247 return resultobj;
14248 fail:
14249 return NULL;
14250 }
14251
14252
14253 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj;
14255 wxGrid *arg1 = (wxGrid *) 0 ;
14256 int arg2 ;
14257 PyObject * obj0 = 0 ;
14258 PyObject * obj1 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self",(char *) "col", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 arg2 = (int)(SWIG_As_int(obj1));
14268 if (SWIG_arg_fail(2)) SWIG_fail;
14269 }
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 (arg1)->AutoSizeColLabelSize(arg2);
14273
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 Py_INCREF(Py_None); resultobj = Py_None;
14278 return resultobj;
14279 fail:
14280 return NULL;
14281 }
14282
14283
14284 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14285 PyObject *resultobj;
14286 wxGrid *arg1 = (wxGrid *) 0 ;
14287 int arg2 ;
14288 int arg3 ;
14289 PyObject * obj0 = 0 ;
14290 PyObject * obj1 = 0 ;
14291 PyObject * obj2 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self",(char *) "col",(char *) "width", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 {
14300 arg2 = (int)(SWIG_As_int(obj1));
14301 if (SWIG_arg_fail(2)) SWIG_fail;
14302 }
14303 {
14304 arg3 = (int)(SWIG_As_int(obj2));
14305 if (SWIG_arg_fail(3)) SWIG_fail;
14306 }
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 (arg1)->SetColMinimalWidth(arg2,arg3);
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 Py_INCREF(Py_None); resultobj = Py_None;
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxGrid *arg1 = (wxGrid *) 0 ;
14324 int arg2 ;
14325 int arg3 ;
14326 PyObject * obj0 = 0 ;
14327 PyObject * obj1 = 0 ;
14328 PyObject * obj2 = 0 ;
14329 char *kwnames[] = {
14330 (char *) "self",(char *) "row",(char *) "width", NULL
14331 };
14332
14333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14335 if (SWIG_arg_fail(1)) SWIG_fail;
14336 {
14337 arg2 = (int)(SWIG_As_int(obj1));
14338 if (SWIG_arg_fail(2)) SWIG_fail;
14339 }
14340 {
14341 arg3 = (int)(SWIG_As_int(obj2));
14342 if (SWIG_arg_fail(3)) SWIG_fail;
14343 }
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 (arg1)->SetRowMinimalHeight(arg2,arg3);
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 Py_INCREF(Py_None); resultobj = Py_None;
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxGrid *arg1 = (wxGrid *) 0 ;
14361 int arg2 ;
14362 PyObject * obj0 = 0 ;
14363 PyObject * obj1 = 0 ;
14364 char *kwnames[] = {
14365 (char *) "self",(char *) "width", NULL
14366 };
14367
14368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14370 if (SWIG_arg_fail(1)) SWIG_fail;
14371 {
14372 arg2 = (int)(SWIG_As_int(obj1));
14373 if (SWIG_arg_fail(2)) SWIG_fail;
14374 }
14375 {
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 (arg1)->SetColMinimalAcceptableWidth(arg2);
14378
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 Py_INCREF(Py_None); resultobj = Py_None;
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj;
14391 wxGrid *arg1 = (wxGrid *) 0 ;
14392 int arg2 ;
14393 PyObject * obj0 = 0 ;
14394 PyObject * obj1 = 0 ;
14395 char *kwnames[] = {
14396 (char *) "self",(char *) "width", NULL
14397 };
14398
14399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14401 if (SWIG_arg_fail(1)) SWIG_fail;
14402 {
14403 arg2 = (int)(SWIG_As_int(obj1));
14404 if (SWIG_arg_fail(2)) SWIG_fail;
14405 }
14406 {
14407 PyThreadState* __tstate = wxPyBeginAllowThreads();
14408 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14409
14410 wxPyEndAllowThreads(__tstate);
14411 if (PyErr_Occurred()) SWIG_fail;
14412 }
14413 Py_INCREF(Py_None); resultobj = Py_None;
14414 return resultobj;
14415 fail:
14416 return NULL;
14417 }
14418
14419
14420 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14421 PyObject *resultobj;
14422 wxGrid *arg1 = (wxGrid *) 0 ;
14423 int result;
14424 PyObject * obj0 = 0 ;
14425 char *kwnames[] = {
14426 (char *) "self", NULL
14427 };
14428
14429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14431 if (SWIG_arg_fail(1)) SWIG_fail;
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 {
14440 resultobj = SWIG_From_int((int)(result));
14441 }
14442 return resultobj;
14443 fail:
14444 return NULL;
14445 }
14446
14447
14448 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14449 PyObject *resultobj;
14450 wxGrid *arg1 = (wxGrid *) 0 ;
14451 int result;
14452 PyObject * obj0 = 0 ;
14453 char *kwnames[] = {
14454 (char *) "self", NULL
14455 };
14456
14457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14459 if (SWIG_arg_fail(1)) SWIG_fail;
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14463
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 {
14468 resultobj = SWIG_From_int((int)(result));
14469 }
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj;
14478 wxGrid *arg1 = (wxGrid *) 0 ;
14479 wxColour *arg2 = 0 ;
14480 wxColour temp2 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 char *kwnames[] = {
14484 (char *) "self","arg2", NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14489 if (SWIG_arg_fail(1)) SWIG_fail;
14490 {
14491 arg2 = &temp2;
14492 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14493 }
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14497
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 Py_INCREF(Py_None); resultobj = Py_None;
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj;
14510 wxGrid *arg1 = (wxGrid *) 0 ;
14511 int arg2 ;
14512 int arg3 ;
14513 wxColour *arg4 = 0 ;
14514 wxColour temp4 ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 PyObject * obj2 = 0 ;
14518 PyObject * obj3 = 0 ;
14519 char *kwnames[] = {
14520 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14521 };
14522
14523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14525 if (SWIG_arg_fail(1)) SWIG_fail;
14526 {
14527 arg2 = (int)(SWIG_As_int(obj1));
14528 if (SWIG_arg_fail(2)) SWIG_fail;
14529 }
14530 {
14531 arg3 = (int)(SWIG_As_int(obj2));
14532 if (SWIG_arg_fail(3)) SWIG_fail;
14533 }
14534 {
14535 arg4 = &temp4;
14536 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14537 }
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 Py_INCREF(Py_None); resultobj = Py_None;
14546 return resultobj;
14547 fail:
14548 return NULL;
14549 }
14550
14551
14552 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj;
14554 wxGrid *arg1 = (wxGrid *) 0 ;
14555 wxColour *arg2 = 0 ;
14556 wxColour temp2 ;
14557 PyObject * obj0 = 0 ;
14558 PyObject * obj1 = 0 ;
14559 char *kwnames[] = {
14560 (char *) "self","arg2", NULL
14561 };
14562
14563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 {
14567 arg2 = &temp2;
14568 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14569 }
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14573
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 Py_INCREF(Py_None); resultobj = Py_None;
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14585 PyObject *resultobj;
14586 wxGrid *arg1 = (wxGrid *) 0 ;
14587 int arg2 ;
14588 int arg3 ;
14589 wxColour *arg4 = 0 ;
14590 wxColour temp4 ;
14591 PyObject * obj0 = 0 ;
14592 PyObject * obj1 = 0 ;
14593 PyObject * obj2 = 0 ;
14594 PyObject * obj3 = 0 ;
14595 char *kwnames[] = {
14596 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14597 };
14598
14599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14601 if (SWIG_arg_fail(1)) SWIG_fail;
14602 {
14603 arg2 = (int)(SWIG_As_int(obj1));
14604 if (SWIG_arg_fail(2)) SWIG_fail;
14605 }
14606 {
14607 arg3 = (int)(SWIG_As_int(obj2));
14608 if (SWIG_arg_fail(3)) SWIG_fail;
14609 }
14610 {
14611 arg4 = &temp4;
14612 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14613 }
14614 {
14615 PyThreadState* __tstate = wxPyBeginAllowThreads();
14616 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14617
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 Py_INCREF(Py_None); resultobj = Py_None;
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj;
14630 wxGrid *arg1 = (wxGrid *) 0 ;
14631 wxFont *arg2 = 0 ;
14632 PyObject * obj0 = 0 ;
14633 PyObject * obj1 = 0 ;
14634 char *kwnames[] = {
14635 (char *) "self","arg2", NULL
14636 };
14637
14638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14640 if (SWIG_arg_fail(1)) SWIG_fail;
14641 {
14642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14643 if (SWIG_arg_fail(2)) SWIG_fail;
14644 if (arg2 == NULL) {
14645 SWIG_null_ref("wxFont");
14646 }
14647 if (SWIG_arg_fail(2)) SWIG_fail;
14648 }
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14652
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 Py_INCREF(Py_None); resultobj = Py_None;
14657 return resultobj;
14658 fail:
14659 return NULL;
14660 }
14661
14662
14663 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14664 PyObject *resultobj;
14665 wxGrid *arg1 = (wxGrid *) 0 ;
14666 int arg2 ;
14667 int arg3 ;
14668 wxFont *arg4 = 0 ;
14669 PyObject * obj0 = 0 ;
14670 PyObject * obj1 = 0 ;
14671 PyObject * obj2 = 0 ;
14672 PyObject * obj3 = 0 ;
14673 char *kwnames[] = {
14674 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14675 };
14676
14677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14679 if (SWIG_arg_fail(1)) SWIG_fail;
14680 {
14681 arg2 = (int)(SWIG_As_int(obj1));
14682 if (SWIG_arg_fail(2)) SWIG_fail;
14683 }
14684 {
14685 arg3 = (int)(SWIG_As_int(obj2));
14686 if (SWIG_arg_fail(3)) SWIG_fail;
14687 }
14688 {
14689 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14690 if (SWIG_arg_fail(4)) SWIG_fail;
14691 if (arg4 == NULL) {
14692 SWIG_null_ref("wxFont");
14693 }
14694 if (SWIG_arg_fail(4)) SWIG_fail;
14695 }
14696 {
14697 PyThreadState* __tstate = wxPyBeginAllowThreads();
14698 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
14699
14700 wxPyEndAllowThreads(__tstate);
14701 if (PyErr_Occurred()) SWIG_fail;
14702 }
14703 Py_INCREF(Py_None); resultobj = Py_None;
14704 return resultobj;
14705 fail:
14706 return NULL;
14707 }
14708
14709
14710 static PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14711 PyObject *resultobj;
14712 wxGrid *arg1 = (wxGrid *) 0 ;
14713 int arg2 ;
14714 int arg3 ;
14715 PyObject * obj0 = 0 ;
14716 PyObject * obj1 = 0 ;
14717 PyObject * obj2 = 0 ;
14718 char *kwnames[] = {
14719 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14720 };
14721
14722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14724 if (SWIG_arg_fail(1)) SWIG_fail;
14725 {
14726 arg2 = (int)(SWIG_As_int(obj1));
14727 if (SWIG_arg_fail(2)) SWIG_fail;
14728 }
14729 {
14730 arg3 = (int)(SWIG_As_int(obj2));
14731 if (SWIG_arg_fail(3)) SWIG_fail;
14732 }
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14736
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 Py_INCREF(Py_None); resultobj = Py_None;
14741 return resultobj;
14742 fail:
14743 return NULL;
14744 }
14745
14746
14747 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj;
14749 wxGrid *arg1 = (wxGrid *) 0 ;
14750 int arg2 ;
14751 int arg3 ;
14752 int arg4 ;
14753 int arg5 ;
14754 PyObject * obj0 = 0 ;
14755 PyObject * obj1 = 0 ;
14756 PyObject * obj2 = 0 ;
14757 PyObject * obj3 = 0 ;
14758 PyObject * obj4 = 0 ;
14759 char *kwnames[] = {
14760 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14761 };
14762
14763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14765 if (SWIG_arg_fail(1)) SWIG_fail;
14766 {
14767 arg2 = (int)(SWIG_As_int(obj1));
14768 if (SWIG_arg_fail(2)) SWIG_fail;
14769 }
14770 {
14771 arg3 = (int)(SWIG_As_int(obj2));
14772 if (SWIG_arg_fail(3)) SWIG_fail;
14773 }
14774 {
14775 arg4 = (int)(SWIG_As_int(obj3));
14776 if (SWIG_arg_fail(4)) SWIG_fail;
14777 }
14778 {
14779 arg5 = (int)(SWIG_As_int(obj4));
14780 if (SWIG_arg_fail(5)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 Py_INCREF(Py_None); resultobj = Py_None;
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxGrid *arg1 = (wxGrid *) 0 ;
14799 bool arg2 ;
14800 PyObject * obj0 = 0 ;
14801 PyObject * obj1 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self",(char *) "allow", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 arg2 = (bool)(SWIG_As_bool(obj1));
14811 if (SWIG_arg_fail(2)) SWIG_fail;
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 (arg1)->SetDefaultCellOverflow(arg2);
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 Py_INCREF(Py_None); resultobj = Py_None;
14821 return resultobj;
14822 fail:
14823 return NULL;
14824 }
14825
14826
14827 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14828 PyObject *resultobj;
14829 wxGrid *arg1 = (wxGrid *) 0 ;
14830 int arg2 ;
14831 int arg3 ;
14832 bool arg4 ;
14833 PyObject * obj0 = 0 ;
14834 PyObject * obj1 = 0 ;
14835 PyObject * obj2 = 0 ;
14836 PyObject * obj3 = 0 ;
14837 char *kwnames[] = {
14838 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
14839 };
14840
14841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14843 if (SWIG_arg_fail(1)) SWIG_fail;
14844 {
14845 arg2 = (int)(SWIG_As_int(obj1));
14846 if (SWIG_arg_fail(2)) SWIG_fail;
14847 }
14848 {
14849 arg3 = (int)(SWIG_As_int(obj2));
14850 if (SWIG_arg_fail(3)) SWIG_fail;
14851 }
14852 {
14853 arg4 = (bool)(SWIG_As_bool(obj3));
14854 if (SWIG_arg_fail(4)) SWIG_fail;
14855 }
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 (arg1)->SetCellOverflow(arg2,arg3,arg4);
14859
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 Py_INCREF(Py_None); resultobj = Py_None;
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj;
14872 wxGrid *arg1 = (wxGrid *) 0 ;
14873 int arg2 ;
14874 int arg3 ;
14875 int arg4 ;
14876 int arg5 ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 PyObject * obj2 = 0 ;
14880 PyObject * obj3 = 0 ;
14881 PyObject * obj4 = 0 ;
14882 char *kwnames[] = {
14883 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
14884 };
14885
14886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14888 if (SWIG_arg_fail(1)) SWIG_fail;
14889 {
14890 arg2 = (int)(SWIG_As_int(obj1));
14891 if (SWIG_arg_fail(2)) SWIG_fail;
14892 }
14893 {
14894 arg3 = (int)(SWIG_As_int(obj2));
14895 if (SWIG_arg_fail(3)) SWIG_fail;
14896 }
14897 {
14898 arg4 = (int)(SWIG_As_int(obj3));
14899 if (SWIG_arg_fail(4)) SWIG_fail;
14900 }
14901 {
14902 arg5 = (int)(SWIG_As_int(obj4));
14903 if (SWIG_arg_fail(5)) SWIG_fail;
14904 }
14905 {
14906 PyThreadState* __tstate = wxPyBeginAllowThreads();
14907 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
14908
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 Py_INCREF(Py_None); resultobj = Py_None;
14913 return resultobj;
14914 fail:
14915 return NULL;
14916 }
14917
14918
14919 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14920 PyObject *resultobj;
14921 wxGrid *arg1 = (wxGrid *) 0 ;
14922 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "self",(char *) "renderer", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
14930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14931 if (SWIG_arg_fail(1)) SWIG_fail;
14932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14933 if (SWIG_arg_fail(2)) SWIG_fail;
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 (arg1)->SetDefaultRenderer(arg2);
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 Py_INCREF(Py_None); resultobj = Py_None;
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14949 PyObject *resultobj;
14950 wxGrid *arg1 = (wxGrid *) 0 ;
14951 int arg2 ;
14952 int arg3 ;
14953 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 PyObject * obj2 = 0 ;
14957 PyObject * obj3 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 {
14966 arg2 = (int)(SWIG_As_int(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 {
14970 arg3 = (int)(SWIG_As_int(obj2));
14971 if (SWIG_arg_fail(3)) SWIG_fail;
14972 }
14973 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(4)) SWIG_fail;
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 (arg1)->SetCellRenderer(arg2,arg3,arg4);
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 Py_INCREF(Py_None); resultobj = Py_None;
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj;
14991 wxGrid *arg1 = (wxGrid *) 0 ;
14992 wxGridCellRenderer *result;
14993 PyObject * obj0 = 0 ;
14994 char *kwnames[] = {
14995 (char *) "self", NULL
14996 };
14997
14998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
14999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15000 if (SWIG_arg_fail(1)) SWIG_fail;
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 {
15009 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15010 }
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj;
15019 wxGrid *arg1 = (wxGrid *) 0 ;
15020 int arg2 ;
15021 int arg3 ;
15022 wxGridCellRenderer *result;
15023 PyObject * obj0 = 0 ;
15024 PyObject * obj1 = 0 ;
15025 PyObject * obj2 = 0 ;
15026 char *kwnames[] = {
15027 (char *) "self",(char *) "row",(char *) "col", NULL
15028 };
15029
15030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15032 if (SWIG_arg_fail(1)) SWIG_fail;
15033 {
15034 arg2 = (int)(SWIG_As_int(obj1));
15035 if (SWIG_arg_fail(2)) SWIG_fail;
15036 }
15037 {
15038 arg3 = (int)(SWIG_As_int(obj2));
15039 if (SWIG_arg_fail(3)) SWIG_fail;
15040 }
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 {
15049 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15050 }
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj;
15059 wxGrid *arg1 = (wxGrid *) 0 ;
15060 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15061 PyObject * obj0 = 0 ;
15062 PyObject * obj1 = 0 ;
15063 char *kwnames[] = {
15064 (char *) "self",(char *) "editor", NULL
15065 };
15066
15067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15069 if (SWIG_arg_fail(1)) SWIG_fail;
15070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15071 if (SWIG_arg_fail(2)) SWIG_fail;
15072 {
15073 PyThreadState* __tstate = wxPyBeginAllowThreads();
15074 (arg1)->SetDefaultEditor(arg2);
15075
15076 wxPyEndAllowThreads(__tstate);
15077 if (PyErr_Occurred()) SWIG_fail;
15078 }
15079 Py_INCREF(Py_None); resultobj = Py_None;
15080 return resultobj;
15081 fail:
15082 return NULL;
15083 }
15084
15085
15086 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj;
15088 wxGrid *arg1 = (wxGrid *) 0 ;
15089 int arg2 ;
15090 int arg3 ;
15091 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15092 PyObject * obj0 = 0 ;
15093 PyObject * obj1 = 0 ;
15094 PyObject * obj2 = 0 ;
15095 PyObject * obj3 = 0 ;
15096 char *kwnames[] = {
15097 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15098 };
15099
15100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15102 if (SWIG_arg_fail(1)) SWIG_fail;
15103 {
15104 arg2 = (int)(SWIG_As_int(obj1));
15105 if (SWIG_arg_fail(2)) SWIG_fail;
15106 }
15107 {
15108 arg3 = (int)(SWIG_As_int(obj2));
15109 if (SWIG_arg_fail(3)) SWIG_fail;
15110 }
15111 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15112 if (SWIG_arg_fail(4)) SWIG_fail;
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 (arg1)->SetCellEditor(arg2,arg3,arg4);
15116
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 Py_INCREF(Py_None); resultobj = Py_None;
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj;
15129 wxGrid *arg1 = (wxGrid *) 0 ;
15130 wxGridCellEditor *result;
15131 PyObject * obj0 = 0 ;
15132 char *kwnames[] = {
15133 (char *) "self", NULL
15134 };
15135
15136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15138 if (SWIG_arg_fail(1)) SWIG_fail;
15139 {
15140 PyThreadState* __tstate = wxPyBeginAllowThreads();
15141 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15142
15143 wxPyEndAllowThreads(__tstate);
15144 if (PyErr_Occurred()) SWIG_fail;
15145 }
15146 {
15147 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15148 }
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj;
15157 wxGrid *arg1 = (wxGrid *) 0 ;
15158 int arg2 ;
15159 int arg3 ;
15160 wxGridCellEditor *result;
15161 PyObject * obj0 = 0 ;
15162 PyObject * obj1 = 0 ;
15163 PyObject * obj2 = 0 ;
15164 char *kwnames[] = {
15165 (char *) "self",(char *) "row",(char *) "col", NULL
15166 };
15167
15168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15170 if (SWIG_arg_fail(1)) SWIG_fail;
15171 {
15172 arg2 = (int)(SWIG_As_int(obj1));
15173 if (SWIG_arg_fail(2)) SWIG_fail;
15174 }
15175 {
15176 arg3 = (int)(SWIG_As_int(obj2));
15177 if (SWIG_arg_fail(3)) SWIG_fail;
15178 }
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15182
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15196 PyObject *resultobj;
15197 wxGrid *arg1 = (wxGrid *) 0 ;
15198 int arg2 ;
15199 int arg3 ;
15200 wxString result;
15201 PyObject * obj0 = 0 ;
15202 PyObject * obj1 = 0 ;
15203 PyObject * obj2 = 0 ;
15204 char *kwnames[] = {
15205 (char *) "self",(char *) "row",(char *) "col", NULL
15206 };
15207
15208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(1)) SWIG_fail;
15211 {
15212 arg2 = (int)(SWIG_As_int(obj1));
15213 if (SWIG_arg_fail(2)) SWIG_fail;
15214 }
15215 {
15216 arg3 = (int)(SWIG_As_int(obj2));
15217 if (SWIG_arg_fail(3)) SWIG_fail;
15218 }
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (arg1)->GetCellValue(arg2,arg3);
15222
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 {
15227 #if wxUSE_UNICODE
15228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15229 #else
15230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15231 #endif
15232 }
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj;
15241 wxGrid *arg1 = (wxGrid *) 0 ;
15242 int arg2 ;
15243 int arg3 ;
15244 wxString *arg4 = 0 ;
15245 bool temp4 = false ;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 PyObject * obj2 = 0 ;
15249 PyObject * obj3 = 0 ;
15250 char *kwnames[] = {
15251 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15252 };
15253
15254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(1)) SWIG_fail;
15257 {
15258 arg2 = (int)(SWIG_As_int(obj1));
15259 if (SWIG_arg_fail(2)) SWIG_fail;
15260 }
15261 {
15262 arg3 = (int)(SWIG_As_int(obj2));
15263 if (SWIG_arg_fail(3)) SWIG_fail;
15264 }
15265 {
15266 arg4 = wxString_in_helper(obj3);
15267 if (arg4 == NULL) SWIG_fail;
15268 temp4 = true;
15269 }
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15273
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 Py_INCREF(Py_None); resultobj = Py_None;
15278 {
15279 if (temp4)
15280 delete arg4;
15281 }
15282 return resultobj;
15283 fail:
15284 {
15285 if (temp4)
15286 delete arg4;
15287 }
15288 return NULL;
15289 }
15290
15291
15292 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj;
15294 wxGrid *arg1 = (wxGrid *) 0 ;
15295 int arg2 ;
15296 int arg3 ;
15297 bool result;
15298 PyObject * obj0 = 0 ;
15299 PyObject * obj1 = 0 ;
15300 PyObject * obj2 = 0 ;
15301 char *kwnames[] = {
15302 (char *) "self",(char *) "row",(char *) "col", NULL
15303 };
15304
15305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15307 if (SWIG_arg_fail(1)) SWIG_fail;
15308 {
15309 arg2 = (int)(SWIG_As_int(obj1));
15310 if (SWIG_arg_fail(2)) SWIG_fail;
15311 }
15312 {
15313 arg3 = (int)(SWIG_As_int(obj2));
15314 if (SWIG_arg_fail(3)) SWIG_fail;
15315 }
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15319
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 {
15324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15325 }
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj;
15334 wxGrid *arg1 = (wxGrid *) 0 ;
15335 int arg2 ;
15336 int arg3 ;
15337 bool arg4 = (bool) true ;
15338 PyObject * obj0 = 0 ;
15339 PyObject * obj1 = 0 ;
15340 PyObject * obj2 = 0 ;
15341 PyObject * obj3 = 0 ;
15342 char *kwnames[] = {
15343 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15344 };
15345
15346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15348 if (SWIG_arg_fail(1)) SWIG_fail;
15349 {
15350 arg2 = (int)(SWIG_As_int(obj1));
15351 if (SWIG_arg_fail(2)) SWIG_fail;
15352 }
15353 {
15354 arg3 = (int)(SWIG_As_int(obj2));
15355 if (SWIG_arg_fail(3)) SWIG_fail;
15356 }
15357 if (obj3) {
15358 {
15359 arg4 = (bool)(SWIG_As_bool(obj3));
15360 if (SWIG_arg_fail(4)) SWIG_fail;
15361 }
15362 }
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 (arg1)->SetReadOnly(arg2,arg3,arg4);
15366
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 Py_INCREF(Py_None); resultobj = Py_None;
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj;
15379 wxGrid *arg1 = (wxGrid *) 0 ;
15380 int arg2 ;
15381 bool arg3 = (bool) false ;
15382 PyObject * obj0 = 0 ;
15383 PyObject * obj1 = 0 ;
15384 PyObject * obj2 = 0 ;
15385 char *kwnames[] = {
15386 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15387 };
15388
15389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15391 if (SWIG_arg_fail(1)) SWIG_fail;
15392 {
15393 arg2 = (int)(SWIG_As_int(obj1));
15394 if (SWIG_arg_fail(2)) SWIG_fail;
15395 }
15396 if (obj2) {
15397 {
15398 arg3 = (bool)(SWIG_As_bool(obj2));
15399 if (SWIG_arg_fail(3)) SWIG_fail;
15400 }
15401 }
15402 {
15403 PyThreadState* __tstate = wxPyBeginAllowThreads();
15404 (arg1)->SelectRow(arg2,arg3);
15405
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 Py_INCREF(Py_None); resultobj = Py_None;
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15417 PyObject *resultobj;
15418 wxGrid *arg1 = (wxGrid *) 0 ;
15419 int arg2 ;
15420 bool arg3 = (bool) false ;
15421 PyObject * obj0 = 0 ;
15422 PyObject * obj1 = 0 ;
15423 PyObject * obj2 = 0 ;
15424 char *kwnames[] = {
15425 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15426 };
15427
15428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15430 if (SWIG_arg_fail(1)) SWIG_fail;
15431 {
15432 arg2 = (int)(SWIG_As_int(obj1));
15433 if (SWIG_arg_fail(2)) SWIG_fail;
15434 }
15435 if (obj2) {
15436 {
15437 arg3 = (bool)(SWIG_As_bool(obj2));
15438 if (SWIG_arg_fail(3)) SWIG_fail;
15439 }
15440 }
15441 {
15442 PyThreadState* __tstate = wxPyBeginAllowThreads();
15443 (arg1)->SelectCol(arg2,arg3);
15444
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 Py_INCREF(Py_None); resultobj = Py_None;
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15456 PyObject *resultobj;
15457 wxGrid *arg1 = (wxGrid *) 0 ;
15458 int arg2 ;
15459 int arg3 ;
15460 int arg4 ;
15461 int arg5 ;
15462 bool arg6 = (bool) false ;
15463 PyObject * obj0 = 0 ;
15464 PyObject * obj1 = 0 ;
15465 PyObject * obj2 = 0 ;
15466 PyObject * obj3 = 0 ;
15467 PyObject * obj4 = 0 ;
15468 PyObject * obj5 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 arg2 = (int)(SWIG_As_int(obj1));
15478 if (SWIG_arg_fail(2)) SWIG_fail;
15479 }
15480 {
15481 arg3 = (int)(SWIG_As_int(obj2));
15482 if (SWIG_arg_fail(3)) SWIG_fail;
15483 }
15484 {
15485 arg4 = (int)(SWIG_As_int(obj3));
15486 if (SWIG_arg_fail(4)) SWIG_fail;
15487 }
15488 {
15489 arg5 = (int)(SWIG_As_int(obj4));
15490 if (SWIG_arg_fail(5)) SWIG_fail;
15491 }
15492 if (obj5) {
15493 {
15494 arg6 = (bool)(SWIG_As_bool(obj5));
15495 if (SWIG_arg_fail(6)) SWIG_fail;
15496 }
15497 }
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15501
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 Py_INCREF(Py_None); resultobj = Py_None;
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15513 PyObject *resultobj;
15514 wxGrid *arg1 = (wxGrid *) 0 ;
15515 PyObject * obj0 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 (arg1)->SelectAll();
15526
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 Py_INCREF(Py_None); resultobj = Py_None;
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj;
15539 wxGrid *arg1 = (wxGrid *) 0 ;
15540 bool result;
15541 PyObject * obj0 = 0 ;
15542 char *kwnames[] = {
15543 (char *) "self", NULL
15544 };
15545
15546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15548 if (SWIG_arg_fail(1)) SWIG_fail;
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 result = (bool)(arg1)->IsSelection();
15552
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 {
15557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15558 }
15559 return resultobj;
15560 fail:
15561 return NULL;
15562 }
15563
15564
15565 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj;
15567 wxGrid *arg1 = (wxGrid *) 0 ;
15568 PyObject * obj0 = 0 ;
15569 char *kwnames[] = {
15570 (char *) "self", NULL
15571 };
15572
15573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15575 if (SWIG_arg_fail(1)) SWIG_fail;
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 (arg1)->ClearSelection();
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 Py_INCREF(Py_None); resultobj = Py_None;
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15591 PyObject *resultobj;
15592 wxGrid *arg1 = (wxGrid *) 0 ;
15593 int arg2 ;
15594 int arg3 ;
15595 bool result;
15596 PyObject * obj0 = 0 ;
15597 PyObject * obj1 = 0 ;
15598 PyObject * obj2 = 0 ;
15599 char *kwnames[] = {
15600 (char *) "self",(char *) "row",(char *) "col", NULL
15601 };
15602
15603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15605 if (SWIG_arg_fail(1)) SWIG_fail;
15606 {
15607 arg2 = (int)(SWIG_As_int(obj1));
15608 if (SWIG_arg_fail(2)) SWIG_fail;
15609 }
15610 {
15611 arg3 = (int)(SWIG_As_int(obj2));
15612 if (SWIG_arg_fail(3)) SWIG_fail;
15613 }
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 {
15622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15623 }
15624 return resultobj;
15625 fail:
15626 return NULL;
15627 }
15628
15629
15630 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15631 PyObject *resultobj;
15632 wxGrid *arg1 = (wxGrid *) 0 ;
15633 wxGridCellCoordsArray result;
15634 PyObject * obj0 = 0 ;
15635 char *kwnames[] = {
15636 (char *) "self", NULL
15637 };
15638
15639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15641 if (SWIG_arg_fail(1)) SWIG_fail;
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = ((wxGrid const *)arg1)->GetSelectedCells();
15645
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 {
15650 resultobj = wxGridCellCoordsArray_helper(result);
15651 }
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15659 PyObject *resultobj;
15660 wxGrid *arg1 = (wxGrid *) 0 ;
15661 wxGridCellCoordsArray result;
15662 PyObject * obj0 = 0 ;
15663 char *kwnames[] = {
15664 (char *) "self", NULL
15665 };
15666
15667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) goto fail;
15668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15669 if (SWIG_arg_fail(1)) SWIG_fail;
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15673
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 {
15678 resultobj = wxGridCellCoordsArray_helper(result);
15679 }
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15687 PyObject *resultobj;
15688 wxGrid *arg1 = (wxGrid *) 0 ;
15689 wxGridCellCoordsArray result;
15690 PyObject * obj0 = 0 ;
15691 char *kwnames[] = {
15692 (char *) "self", NULL
15693 };
15694
15695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15697 if (SWIG_arg_fail(1)) SWIG_fail;
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15701
15702 wxPyEndAllowThreads(__tstate);
15703 if (PyErr_Occurred()) SWIG_fail;
15704 }
15705 {
15706 resultobj = wxGridCellCoordsArray_helper(result);
15707 }
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15715 PyObject *resultobj;
15716 wxGrid *arg1 = (wxGrid *) 0 ;
15717 wxArrayInt result;
15718 PyObject * obj0 = 0 ;
15719 char *kwnames[] = {
15720 (char *) "self", NULL
15721 };
15722
15723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15725 if (SWIG_arg_fail(1)) SWIG_fail;
15726 {
15727 PyThreadState* __tstate = wxPyBeginAllowThreads();
15728 result = ((wxGrid const *)arg1)->GetSelectedRows();
15729
15730 wxPyEndAllowThreads(__tstate);
15731 if (PyErr_Occurred()) SWIG_fail;
15732 }
15733 {
15734 resultobj = PyList_New(0);
15735 size_t idx;
15736 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15737 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15738 PyList_Append(resultobj, val);
15739 Py_DECREF(val);
15740 }
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxGrid *arg1 = (wxGrid *) 0 ;
15751 wxArrayInt result;
15752 PyObject * obj0 = 0 ;
15753 char *kwnames[] = {
15754 (char *) "self", NULL
15755 };
15756
15757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15759 if (SWIG_arg_fail(1)) SWIG_fail;
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = ((wxGrid const *)arg1)->GetSelectedCols();
15763
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 {
15768 resultobj = PyList_New(0);
15769 size_t idx;
15770 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15771 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15772 PyList_Append(resultobj, val);
15773 Py_DECREF(val);
15774 }
15775 }
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15783 PyObject *resultobj;
15784 wxGrid *arg1 = (wxGrid *) 0 ;
15785 int arg2 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 char *kwnames[] = {
15789 (char *) "self",(char *) "row", NULL
15790 };
15791
15792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
15793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15794 if (SWIG_arg_fail(1)) SWIG_fail;
15795 {
15796 arg2 = (int)(SWIG_As_int(obj1));
15797 if (SWIG_arg_fail(2)) SWIG_fail;
15798 }
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 (arg1)->DeselectRow(arg2);
15802
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 Py_INCREF(Py_None); resultobj = Py_None;
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15814 PyObject *resultobj;
15815 wxGrid *arg1 = (wxGrid *) 0 ;
15816 int arg2 ;
15817 PyObject * obj0 = 0 ;
15818 PyObject * obj1 = 0 ;
15819 char *kwnames[] = {
15820 (char *) "self",(char *) "col", NULL
15821 };
15822
15823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
15824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15825 if (SWIG_arg_fail(1)) SWIG_fail;
15826 {
15827 arg2 = (int)(SWIG_As_int(obj1));
15828 if (SWIG_arg_fail(2)) SWIG_fail;
15829 }
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 (arg1)->DeselectCol(arg2);
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 Py_INCREF(Py_None); resultobj = Py_None;
15838 return resultobj;
15839 fail:
15840 return NULL;
15841 }
15842
15843
15844 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
15845 PyObject *resultobj;
15846 wxGrid *arg1 = (wxGrid *) 0 ;
15847 int arg2 ;
15848 int arg3 ;
15849 PyObject * obj0 = 0 ;
15850 PyObject * obj1 = 0 ;
15851 PyObject * obj2 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self",(char *) "row",(char *) "col", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 {
15860 arg2 = (int)(SWIG_As_int(obj1));
15861 if (SWIG_arg_fail(2)) SWIG_fail;
15862 }
15863 {
15864 arg3 = (int)(SWIG_As_int(obj2));
15865 if (SWIG_arg_fail(3)) SWIG_fail;
15866 }
15867 {
15868 PyThreadState* __tstate = wxPyBeginAllowThreads();
15869 (arg1)->DeselectCell(arg2,arg3);
15870
15871 wxPyEndAllowThreads(__tstate);
15872 if (PyErr_Occurred()) SWIG_fail;
15873 }
15874 Py_INCREF(Py_None); resultobj = Py_None;
15875 return resultobj;
15876 fail:
15877 return NULL;
15878 }
15879
15880
15881 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj;
15883 wxGrid *arg1 = (wxGrid *) 0 ;
15884 wxGridCellCoords *arg2 = 0 ;
15885 wxGridCellCoords *arg3 = 0 ;
15886 wxRect result;
15887 wxGridCellCoords temp2 ;
15888 wxGridCellCoords temp3 ;
15889 PyObject * obj0 = 0 ;
15890 PyObject * obj1 = 0 ;
15891 PyObject * obj2 = 0 ;
15892 char *kwnames[] = {
15893 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
15894 };
15895
15896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
15897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15898 if (SWIG_arg_fail(1)) SWIG_fail;
15899 {
15900 arg2 = &temp2;
15901 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
15902 }
15903 {
15904 arg3 = &temp3;
15905 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
15906 }
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
15910
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 {
15915 wxRect * resultptr;
15916 resultptr = new wxRect((wxRect &)(result));
15917 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15918 }
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15926 PyObject *resultobj;
15927 wxGrid *arg1 = (wxGrid *) 0 ;
15928 wxColour result;
15929 PyObject * obj0 = 0 ;
15930 char *kwnames[] = {
15931 (char *) "self", NULL
15932 };
15933
15934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
15935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15936 if (SWIG_arg_fail(1)) SWIG_fail;
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = ((wxGrid const *)arg1)->GetSelectionBackground();
15940
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 {
15945 wxColour * resultptr;
15946 resultptr = new wxColour((wxColour &)(result));
15947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15948 }
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15956 PyObject *resultobj;
15957 wxGrid *arg1 = (wxGrid *) 0 ;
15958 wxColour result;
15959 PyObject * obj0 = 0 ;
15960 char *kwnames[] = {
15961 (char *) "self", NULL
15962 };
15963
15964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
15965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15966 if (SWIG_arg_fail(1)) SWIG_fail;
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 result = ((wxGrid const *)arg1)->GetSelectionForeground();
15970
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 {
15975 wxColour * resultptr;
15976 resultptr = new wxColour((wxColour &)(result));
15977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15978 }
15979 return resultobj;
15980 fail:
15981 return NULL;
15982 }
15983
15984
15985 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15986 PyObject *resultobj;
15987 wxGrid *arg1 = (wxGrid *) 0 ;
15988 wxColour *arg2 = 0 ;
15989 wxColour temp2 ;
15990 PyObject * obj0 = 0 ;
15991 PyObject * obj1 = 0 ;
15992 char *kwnames[] = {
15993 (char *) "self",(char *) "c", NULL
15994 };
15995
15996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
15997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15998 if (SWIG_arg_fail(1)) SWIG_fail;
15999 {
16000 arg2 = &temp2;
16001 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16002 }
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16006
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 Py_INCREF(Py_None); resultobj = Py_None;
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj;
16019 wxGrid *arg1 = (wxGrid *) 0 ;
16020 wxColour *arg2 = 0 ;
16021 wxColour temp2 ;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 char *kwnames[] = {
16025 (char *) "self",(char *) "c", NULL
16026 };
16027
16028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) goto fail;
16029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16030 if (SWIG_arg_fail(1)) SWIG_fail;
16031 {
16032 arg2 = &temp2;
16033 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16034 }
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16038
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 Py_INCREF(Py_None); resultobj = Py_None;
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj;
16051 wxGrid *arg1 = (wxGrid *) 0 ;
16052 wxString *arg2 = 0 ;
16053 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16054 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16055 bool temp2 = false ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 PyObject * obj2 = 0 ;
16059 PyObject * obj3 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 {
16068 arg2 = wxString_in_helper(obj1);
16069 if (arg2 == NULL) SWIG_fail;
16070 temp2 = true;
16071 }
16072 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16073 if (SWIG_arg_fail(3)) SWIG_fail;
16074 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16075 if (SWIG_arg_fail(4)) SWIG_fail;
16076 {
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16079
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 Py_INCREF(Py_None); resultobj = Py_None;
16084 {
16085 if (temp2)
16086 delete arg2;
16087 }
16088 return resultobj;
16089 fail:
16090 {
16091 if (temp2)
16092 delete arg2;
16093 }
16094 return NULL;
16095 }
16096
16097
16098 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16099 PyObject *resultobj;
16100 wxGrid *arg1 = (wxGrid *) 0 ;
16101 int arg2 ;
16102 int arg3 ;
16103 wxGridCellEditor *result;
16104 PyObject * obj0 = 0 ;
16105 PyObject * obj1 = 0 ;
16106 PyObject * obj2 = 0 ;
16107 char *kwnames[] = {
16108 (char *) "self",(char *) "row",(char *) "col", NULL
16109 };
16110
16111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16113 if (SWIG_arg_fail(1)) SWIG_fail;
16114 {
16115 arg2 = (int)(SWIG_As_int(obj1));
16116 if (SWIG_arg_fail(2)) SWIG_fail;
16117 }
16118 {
16119 arg3 = (int)(SWIG_As_int(obj2));
16120 if (SWIG_arg_fail(3)) SWIG_fail;
16121 }
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16125
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 {
16130 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16131 }
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16139 PyObject *resultobj;
16140 wxGrid *arg1 = (wxGrid *) 0 ;
16141 int arg2 ;
16142 int arg3 ;
16143 wxGridCellRenderer *result;
16144 PyObject * obj0 = 0 ;
16145 PyObject * obj1 = 0 ;
16146 PyObject * obj2 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "self",(char *) "row",(char *) "col", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 arg2 = (int)(SWIG_As_int(obj1));
16156 if (SWIG_arg_fail(2)) SWIG_fail;
16157 }
16158 {
16159 arg3 = (int)(SWIG_As_int(obj2));
16160 if (SWIG_arg_fail(3)) SWIG_fail;
16161 }
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 {
16170 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16171 }
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16179 PyObject *resultobj;
16180 wxGrid *arg1 = (wxGrid *) 0 ;
16181 wxString *arg2 = 0 ;
16182 wxGridCellEditor *result;
16183 bool temp2 = false ;
16184 PyObject * obj0 = 0 ;
16185 PyObject * obj1 = 0 ;
16186 char *kwnames[] = {
16187 (char *) "self",(char *) "typeName", NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16192 if (SWIG_arg_fail(1)) SWIG_fail;
16193 {
16194 arg2 = wxString_in_helper(obj1);
16195 if (arg2 == NULL) SWIG_fail;
16196 temp2 = true;
16197 }
16198 {
16199 PyThreadState* __tstate = wxPyBeginAllowThreads();
16200 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16201
16202 wxPyEndAllowThreads(__tstate);
16203 if (PyErr_Occurred()) SWIG_fail;
16204 }
16205 {
16206 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16207 }
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 return resultobj;
16213 fail:
16214 {
16215 if (temp2)
16216 delete arg2;
16217 }
16218 return NULL;
16219 }
16220
16221
16222 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj;
16224 wxGrid *arg1 = (wxGrid *) 0 ;
16225 wxString *arg2 = 0 ;
16226 wxGridCellRenderer *result;
16227 bool temp2 = false ;
16228 PyObject * obj0 = 0 ;
16229 PyObject * obj1 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self",(char *) "typeName", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 arg2 = wxString_in_helper(obj1);
16239 if (arg2 == NULL) SWIG_fail;
16240 temp2 = true;
16241 }
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16245
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 {
16250 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16251 }
16252 {
16253 if (temp2)
16254 delete arg2;
16255 }
16256 return resultobj;
16257 fail:
16258 {
16259 if (temp2)
16260 delete arg2;
16261 }
16262 return NULL;
16263 }
16264
16265
16266 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16267 PyObject *resultobj;
16268 wxGrid *arg1 = (wxGrid *) 0 ;
16269 int arg2 ;
16270 int arg3 ;
16271 PyObject * obj0 = 0 ;
16272 PyObject * obj1 = 0 ;
16273 PyObject * obj2 = 0 ;
16274 char *kwnames[] = {
16275 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16276 };
16277
16278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16280 if (SWIG_arg_fail(1)) SWIG_fail;
16281 {
16282 arg2 = (int)(SWIG_As_int(obj1));
16283 if (SWIG_arg_fail(2)) SWIG_fail;
16284 }
16285 {
16286 arg3 = (int)(SWIG_As_int(obj2));
16287 if (SWIG_arg_fail(3)) SWIG_fail;
16288 }
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 (arg1)->SetMargins(arg2,arg3);
16292
16293 wxPyEndAllowThreads(__tstate);
16294 if (PyErr_Occurred()) SWIG_fail;
16295 }
16296 Py_INCREF(Py_None); resultobj = Py_None;
16297 return resultobj;
16298 fail:
16299 return NULL;
16300 }
16301
16302
16303 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16304 PyObject *resultobj;
16305 wxGrid *arg1 = (wxGrid *) 0 ;
16306 wxWindow *result;
16307 PyObject * obj0 = 0 ;
16308 char *kwnames[] = {
16309 (char *) "self", NULL
16310 };
16311
16312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16314 if (SWIG_arg_fail(1)) SWIG_fail;
16315 {
16316 PyThreadState* __tstate = wxPyBeginAllowThreads();
16317 result = (wxWindow *)(arg1)->GetGridWindow();
16318
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = wxPyMake_wxObject(result, 0);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj;
16333 wxGrid *arg1 = (wxGrid *) 0 ;
16334 wxWindow *result;
16335 PyObject * obj0 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16346
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 {
16351 resultobj = wxPyMake_wxObject(result, 0);
16352 }
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj;
16361 wxGrid *arg1 = (wxGrid *) 0 ;
16362 wxWindow *result;
16363 PyObject * obj0 = 0 ;
16364 char *kwnames[] = {
16365 (char *) "self", NULL
16366 };
16367
16368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16370 if (SWIG_arg_fail(1)) SWIG_fail;
16371 {
16372 PyThreadState* __tstate = wxPyBeginAllowThreads();
16373 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16374
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 {
16379 resultobj = wxPyMake_wxObject(result, 0);
16380 }
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj;
16389 wxGrid *arg1 = (wxGrid *) 0 ;
16390 wxWindow *result;
16391 PyObject * obj0 = 0 ;
16392 char *kwnames[] = {
16393 (char *) "self", NULL
16394 };
16395
16396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16398 if (SWIG_arg_fail(1)) SWIG_fail;
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16402
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 {
16407 resultobj = wxPyMake_wxObject(result, 0);
16408 }
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj;
16417 wxGrid *arg1 = (wxGrid *) 0 ;
16418 int arg2 ;
16419 PyObject * obj0 = 0 ;
16420 PyObject * obj1 = 0 ;
16421 char *kwnames[] = {
16422 (char *) "self",(char *) "x", NULL
16423 };
16424
16425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 {
16429 arg2 = (int)(SWIG_As_int(obj1));
16430 if (SWIG_arg_fail(2)) SWIG_fail;
16431 }
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 (arg1)->SetScrollLineX(arg2);
16435
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 Py_INCREF(Py_None); resultobj = Py_None;
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxGrid *arg1 = (wxGrid *) 0 ;
16449 int arg2 ;
16450 PyObject * obj0 = 0 ;
16451 PyObject * obj1 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "self",(char *) "y", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16458 if (SWIG_arg_fail(1)) SWIG_fail;
16459 {
16460 arg2 = (int)(SWIG_As_int(obj1));
16461 if (SWIG_arg_fail(2)) SWIG_fail;
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 (arg1)->SetScrollLineY(arg2);
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 Py_INCREF(Py_None); resultobj = Py_None;
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxGrid *arg1 = (wxGrid *) 0 ;
16480 int result;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = SWIG_From_int((int)(result));
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxGrid *arg1 = (wxGrid *) 0 ;
16508 int result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = SWIG_From_int((int)(result));
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxGrid *arg1 = (wxGrid *) 0 ;
16536 int arg2 ;
16537 int result;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self",(char *) "x", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 arg2 = (int)(SWIG_As_int(obj1));
16549 if (SWIG_arg_fail(2)) SWIG_fail;
16550 }
16551 {
16552 PyThreadState* __tstate = wxPyBeginAllowThreads();
16553 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16554
16555 wxPyEndAllowThreads(__tstate);
16556 if (PyErr_Occurred()) SWIG_fail;
16557 }
16558 {
16559 resultobj = SWIG_From_int((int)(result));
16560 }
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxGrid *arg1 = (wxGrid *) 0 ;
16570 int arg2 ;
16571 int result;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16574 char *kwnames[] = {
16575 (char *) "self",(char *) "y", NULL
16576 };
16577
16578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) goto fail;
16579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16580 if (SWIG_arg_fail(1)) SWIG_fail;
16581 {
16582 arg2 = (int)(SWIG_As_int(obj1));
16583 if (SWIG_arg_fail(2)) SWIG_fail;
16584 }
16585 {
16586 PyThreadState* __tstate = wxPyBeginAllowThreads();
16587 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16588
16589 wxPyEndAllowThreads(__tstate);
16590 if (PyErr_Occurred()) SWIG_fail;
16591 }
16592 {
16593 resultobj = SWIG_From_int((int)(result));
16594 }
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16602 PyObject *resultobj;
16603 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16604 wxVisualAttributes result;
16605 PyObject * obj0 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "variant", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16611 if (obj0) {
16612 {
16613 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 }
16616 }
16617 {
16618 if (!wxPyCheckForApp()) SWIG_fail;
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 result = wxGrid::GetClassDefaultAttributes((wxWindowVariant )arg1);
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 wxVisualAttributes * resultptr;
16627 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16629 }
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16637 PyObject *obj;
16638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16639 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16640 Py_INCREF(obj);
16641 return Py_BuildValue((char *)"");
16642 }
16643 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 int arg1 ;
16646 wxEventType arg2 ;
16647 wxGrid *arg3 = (wxGrid *) 0 ;
16648 int arg4 = (int) -1 ;
16649 int arg5 = (int) -1 ;
16650 int arg6 = (int) -1 ;
16651 int arg7 = (int) -1 ;
16652 bool arg8 = (bool) true ;
16653 bool arg9 = (bool) false ;
16654 bool arg10 = (bool) false ;
16655 bool arg11 = (bool) false ;
16656 bool arg12 = (bool) false ;
16657 wxGridEvent *result;
16658 PyObject * obj0 = 0 ;
16659 PyObject * obj1 = 0 ;
16660 PyObject * obj2 = 0 ;
16661 PyObject * obj3 = 0 ;
16662 PyObject * obj4 = 0 ;
16663 PyObject * obj5 = 0 ;
16664 PyObject * obj6 = 0 ;
16665 PyObject * obj7 = 0 ;
16666 PyObject * obj8 = 0 ;
16667 PyObject * obj9 = 0 ;
16668 PyObject * obj10 = 0 ;
16669 PyObject * obj11 = 0 ;
16670 char *kwnames[] = {
16671 (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
16672 };
16673
16674 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;
16675 {
16676 arg1 = (int)(SWIG_As_int(obj0));
16677 if (SWIG_arg_fail(1)) SWIG_fail;
16678 }
16679 {
16680 arg2 = (wxEventType)(SWIG_As_int(obj1));
16681 if (SWIG_arg_fail(2)) SWIG_fail;
16682 }
16683 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16684 if (SWIG_arg_fail(3)) SWIG_fail;
16685 if (obj3) {
16686 {
16687 arg4 = (int)(SWIG_As_int(obj3));
16688 if (SWIG_arg_fail(4)) SWIG_fail;
16689 }
16690 }
16691 if (obj4) {
16692 {
16693 arg5 = (int)(SWIG_As_int(obj4));
16694 if (SWIG_arg_fail(5)) SWIG_fail;
16695 }
16696 }
16697 if (obj5) {
16698 {
16699 arg6 = (int)(SWIG_As_int(obj5));
16700 if (SWIG_arg_fail(6)) SWIG_fail;
16701 }
16702 }
16703 if (obj6) {
16704 {
16705 arg7 = (int)(SWIG_As_int(obj6));
16706 if (SWIG_arg_fail(7)) SWIG_fail;
16707 }
16708 }
16709 if (obj7) {
16710 {
16711 arg8 = (bool)(SWIG_As_bool(obj7));
16712 if (SWIG_arg_fail(8)) SWIG_fail;
16713 }
16714 }
16715 if (obj8) {
16716 {
16717 arg9 = (bool)(SWIG_As_bool(obj8));
16718 if (SWIG_arg_fail(9)) SWIG_fail;
16719 }
16720 }
16721 if (obj9) {
16722 {
16723 arg10 = (bool)(SWIG_As_bool(obj9));
16724 if (SWIG_arg_fail(10)) SWIG_fail;
16725 }
16726 }
16727 if (obj10) {
16728 {
16729 arg11 = (bool)(SWIG_As_bool(obj10));
16730 if (SWIG_arg_fail(11)) SWIG_fail;
16731 }
16732 }
16733 if (obj11) {
16734 {
16735 arg12 = (bool)(SWIG_As_bool(obj11));
16736 if (SWIG_arg_fail(12)) SWIG_fail;
16737 }
16738 }
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16742
16743 wxPyEndAllowThreads(__tstate);
16744 if (PyErr_Occurred()) SWIG_fail;
16745 }
16746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16747 return resultobj;
16748 fail:
16749 return NULL;
16750 }
16751
16752
16753 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16754 PyObject *resultobj;
16755 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16756 int result;
16757 PyObject * obj0 = 0 ;
16758 char *kwnames[] = {
16759 (char *) "self", NULL
16760 };
16761
16762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16764 if (SWIG_arg_fail(1)) SWIG_fail;
16765 {
16766 PyThreadState* __tstate = wxPyBeginAllowThreads();
16767 result = (int)(arg1)->GetRow();
16768
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 {
16773 resultobj = SWIG_From_int((int)(result));
16774 }
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj;
16783 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16784 int result;
16785 PyObject * obj0 = 0 ;
16786 char *kwnames[] = {
16787 (char *) "self", NULL
16788 };
16789
16790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
16791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16792 if (SWIG_arg_fail(1)) SWIG_fail;
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 result = (int)(arg1)->GetCol();
16796
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 {
16801 resultobj = SWIG_From_int((int)(result));
16802 }
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj;
16811 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16812 wxPoint result;
16813 PyObject * obj0 = 0 ;
16814 char *kwnames[] = {
16815 (char *) "self", NULL
16816 };
16817
16818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
16819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16820 if (SWIG_arg_fail(1)) SWIG_fail;
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 result = (arg1)->GetPosition();
16824
16825 wxPyEndAllowThreads(__tstate);
16826 if (PyErr_Occurred()) SWIG_fail;
16827 }
16828 {
16829 wxPoint * resultptr;
16830 resultptr = new wxPoint((wxPoint &)(result));
16831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16832 }
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj;
16841 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16842 bool result;
16843 PyObject * obj0 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "self", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (bool)(arg1)->Selecting();
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 {
16859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16860 }
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj;
16869 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16870 bool result;
16871 PyObject * obj0 = 0 ;
16872 char *kwnames[] = {
16873 (char *) "self", NULL
16874 };
16875
16876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
16877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(1)) SWIG_fail;
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = (bool)(arg1)->ControlDown();
16882
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 {
16887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16888 }
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16896 PyObject *resultobj;
16897 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16898 bool result;
16899 PyObject * obj0 = 0 ;
16900 char *kwnames[] = {
16901 (char *) "self", NULL
16902 };
16903
16904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
16905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16906 if (SWIG_arg_fail(1)) SWIG_fail;
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (bool)(arg1)->MetaDown();
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 {
16915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16916 }
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj;
16925 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16926 bool result;
16927 PyObject * obj0 = 0 ;
16928 char *kwnames[] = {
16929 (char *) "self", NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
16933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 {
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (bool)(arg1)->ShiftDown();
16938
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 {
16943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16944 }
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16952 PyObject *resultobj;
16953 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16954 bool result;
16955 PyObject * obj0 = 0 ;
16956 char *kwnames[] = {
16957 (char *) "self", NULL
16958 };
16959
16960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
16961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16962 if (SWIG_arg_fail(1)) SWIG_fail;
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (bool)(arg1)->AltDown();
16966
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 {
16971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16972 }
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
16980 PyObject *obj;
16981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16982 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
16983 Py_INCREF(obj);
16984 return Py_BuildValue((char *)"");
16985 }
16986 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 int arg1 ;
16989 wxEventType arg2 ;
16990 wxGrid *arg3 = (wxGrid *) 0 ;
16991 int arg4 = (int) -1 ;
16992 int arg5 = (int) -1 ;
16993 int arg6 = (int) -1 ;
16994 bool arg7 = (bool) false ;
16995 bool arg8 = (bool) false ;
16996 bool arg9 = (bool) false ;
16997 bool arg10 = (bool) false ;
16998 wxGridSizeEvent *result;
16999 PyObject * obj0 = 0 ;
17000 PyObject * obj1 = 0 ;
17001 PyObject * obj2 = 0 ;
17002 PyObject * obj3 = 0 ;
17003 PyObject * obj4 = 0 ;
17004 PyObject * obj5 = 0 ;
17005 PyObject * obj6 = 0 ;
17006 PyObject * obj7 = 0 ;
17007 PyObject * obj8 = 0 ;
17008 PyObject * obj9 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17011 };
17012
17013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17014 {
17015 arg1 = (int)(SWIG_As_int(obj0));
17016 if (SWIG_arg_fail(1)) SWIG_fail;
17017 }
17018 {
17019 arg2 = (wxEventType)(SWIG_As_int(obj1));
17020 if (SWIG_arg_fail(2)) SWIG_fail;
17021 }
17022 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17023 if (SWIG_arg_fail(3)) SWIG_fail;
17024 if (obj3) {
17025 {
17026 arg4 = (int)(SWIG_As_int(obj3));
17027 if (SWIG_arg_fail(4)) SWIG_fail;
17028 }
17029 }
17030 if (obj4) {
17031 {
17032 arg5 = (int)(SWIG_As_int(obj4));
17033 if (SWIG_arg_fail(5)) SWIG_fail;
17034 }
17035 }
17036 if (obj5) {
17037 {
17038 arg6 = (int)(SWIG_As_int(obj5));
17039 if (SWIG_arg_fail(6)) SWIG_fail;
17040 }
17041 }
17042 if (obj6) {
17043 {
17044 arg7 = (bool)(SWIG_As_bool(obj6));
17045 if (SWIG_arg_fail(7)) SWIG_fail;
17046 }
17047 }
17048 if (obj7) {
17049 {
17050 arg8 = (bool)(SWIG_As_bool(obj7));
17051 if (SWIG_arg_fail(8)) SWIG_fail;
17052 }
17053 }
17054 if (obj8) {
17055 {
17056 arg9 = (bool)(SWIG_As_bool(obj8));
17057 if (SWIG_arg_fail(9)) SWIG_fail;
17058 }
17059 }
17060 if (obj9) {
17061 {
17062 arg10 = (bool)(SWIG_As_bool(obj9));
17063 if (SWIG_arg_fail(10)) SWIG_fail;
17064 }
17065 }
17066 {
17067 PyThreadState* __tstate = wxPyBeginAllowThreads();
17068 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17069
17070 wxPyEndAllowThreads(__tstate);
17071 if (PyErr_Occurred()) SWIG_fail;
17072 }
17073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17074 return resultobj;
17075 fail:
17076 return NULL;
17077 }
17078
17079
17080 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj;
17082 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17083 int result;
17084 PyObject * obj0 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = (int)(arg1)->GetRowOrCol();
17095
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 {
17100 resultobj = SWIG_From_int((int)(result));
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj;
17110 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17111 wxPoint result;
17112 PyObject * obj0 = 0 ;
17113 char *kwnames[] = {
17114 (char *) "self", NULL
17115 };
17116
17117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17119 if (SWIG_arg_fail(1)) SWIG_fail;
17120 {
17121 PyThreadState* __tstate = wxPyBeginAllowThreads();
17122 result = (arg1)->GetPosition();
17123
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 wxPoint * resultptr;
17129 resultptr = new wxPoint((wxPoint &)(result));
17130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17131 }
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj;
17140 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17141 bool result;
17142 PyObject * obj0 = 0 ;
17143 char *kwnames[] = {
17144 (char *) "self", NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17149 if (SWIG_arg_fail(1)) SWIG_fail;
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (bool)(arg1)->ControlDown();
17153
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj;
17168 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17169 bool result;
17170 PyObject * obj0 = 0 ;
17171 char *kwnames[] = {
17172 (char *) "self", NULL
17173 };
17174
17175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17177 if (SWIG_arg_fail(1)) SWIG_fail;
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (bool)(arg1)->MetaDown();
17181
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 {
17186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17187 }
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17197 bool result;
17198 PyObject * obj0 = 0 ;
17199 char *kwnames[] = {
17200 (char *) "self", NULL
17201 };
17202
17203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17205 if (SWIG_arg_fail(1)) SWIG_fail;
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 result = (bool)(arg1)->ShiftDown();
17209
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 {
17214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17215 }
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj;
17224 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17225 bool result;
17226 PyObject * obj0 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 PyThreadState* __tstate = wxPyBeginAllowThreads();
17236 result = (bool)(arg1)->AltDown();
17237
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 {
17242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17243 }
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17251 PyObject *obj;
17252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17253 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17254 Py_INCREF(obj);
17255 return Py_BuildValue((char *)"");
17256 }
17257 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17258 PyObject *resultobj;
17259 int arg1 ;
17260 wxEventType arg2 ;
17261 wxGrid *arg3 = (wxGrid *) 0 ;
17262 wxGridCellCoords *arg4 = 0 ;
17263 wxGridCellCoords *arg5 = 0 ;
17264 bool arg6 = (bool) true ;
17265 bool arg7 = (bool) false ;
17266 bool arg8 = (bool) false ;
17267 bool arg9 = (bool) false ;
17268 bool arg10 = (bool) false ;
17269 wxGridRangeSelectEvent *result;
17270 wxGridCellCoords temp4 ;
17271 wxGridCellCoords temp5 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275 PyObject * obj3 = 0 ;
17276 PyObject * obj4 = 0 ;
17277 PyObject * obj5 = 0 ;
17278 PyObject * obj6 = 0 ;
17279 PyObject * obj7 = 0 ;
17280 PyObject * obj8 = 0 ;
17281 PyObject * obj9 = 0 ;
17282 char *kwnames[] = {
17283 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17284 };
17285
17286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17287 {
17288 arg1 = (int)(SWIG_As_int(obj0));
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 }
17291 {
17292 arg2 = (wxEventType)(SWIG_As_int(obj1));
17293 if (SWIG_arg_fail(2)) SWIG_fail;
17294 }
17295 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17296 if (SWIG_arg_fail(3)) SWIG_fail;
17297 {
17298 arg4 = &temp4;
17299 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17300 }
17301 {
17302 arg5 = &temp5;
17303 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17304 }
17305 if (obj5) {
17306 {
17307 arg6 = (bool)(SWIG_As_bool(obj5));
17308 if (SWIG_arg_fail(6)) SWIG_fail;
17309 }
17310 }
17311 if (obj6) {
17312 {
17313 arg7 = (bool)(SWIG_As_bool(obj6));
17314 if (SWIG_arg_fail(7)) SWIG_fail;
17315 }
17316 }
17317 if (obj7) {
17318 {
17319 arg8 = (bool)(SWIG_As_bool(obj7));
17320 if (SWIG_arg_fail(8)) SWIG_fail;
17321 }
17322 }
17323 if (obj8) {
17324 {
17325 arg9 = (bool)(SWIG_As_bool(obj8));
17326 if (SWIG_arg_fail(9)) SWIG_fail;
17327 }
17328 }
17329 if (obj9) {
17330 {
17331 arg10 = (bool)(SWIG_As_bool(obj9));
17332 if (SWIG_arg_fail(10)) SWIG_fail;
17333 }
17334 }
17335 {
17336 PyThreadState* __tstate = wxPyBeginAllowThreads();
17337 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17338
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj;
17351 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17352 wxGridCellCoords result;
17353 PyObject * obj0 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (arg1)->GetTopLeftCoords();
17364
17365 wxPyEndAllowThreads(__tstate);
17366 if (PyErr_Occurred()) SWIG_fail;
17367 }
17368 {
17369 wxGridCellCoords * resultptr;
17370 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17371 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17372 }
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj;
17381 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17382 wxGridCellCoords result;
17383 PyObject * obj0 = 0 ;
17384 char *kwnames[] = {
17385 (char *) "self", NULL
17386 };
17387
17388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17390 if (SWIG_arg_fail(1)) SWIG_fail;
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (arg1)->GetBottomRightCoords();
17394
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 {
17399 wxGridCellCoords * resultptr;
17400 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17401 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17402 }
17403 return resultobj;
17404 fail:
17405 return NULL;
17406 }
17407
17408
17409 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17410 PyObject *resultobj;
17411 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17412 int result;
17413 PyObject * obj0 = 0 ;
17414 char *kwnames[] = {
17415 (char *) "self", NULL
17416 };
17417
17418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17420 if (SWIG_arg_fail(1)) SWIG_fail;
17421 {
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 result = (int)(arg1)->GetTopRow();
17424
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 {
17429 resultobj = SWIG_From_int((int)(result));
17430 }
17431 return resultobj;
17432 fail:
17433 return NULL;
17434 }
17435
17436
17437 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17438 PyObject *resultobj;
17439 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17440 int result;
17441 PyObject * obj0 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "self", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 {
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 result = (int)(arg1)->GetBottomRow();
17452
17453 wxPyEndAllowThreads(__tstate);
17454 if (PyErr_Occurred()) SWIG_fail;
17455 }
17456 {
17457 resultobj = SWIG_From_int((int)(result));
17458 }
17459 return resultobj;
17460 fail:
17461 return NULL;
17462 }
17463
17464
17465 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17466 PyObject *resultobj;
17467 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17468 int result;
17469 PyObject * obj0 = 0 ;
17470 char *kwnames[] = {
17471 (char *) "self", NULL
17472 };
17473
17474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17476 if (SWIG_arg_fail(1)) SWIG_fail;
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (int)(arg1)->GetLeftCol();
17480
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 {
17485 resultobj = SWIG_From_int((int)(result));
17486 }
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj;
17495 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17496 int result;
17497 PyObject * obj0 = 0 ;
17498 char *kwnames[] = {
17499 (char *) "self", NULL
17500 };
17501
17502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17504 if (SWIG_arg_fail(1)) SWIG_fail;
17505 {
17506 PyThreadState* __tstate = wxPyBeginAllowThreads();
17507 result = (int)(arg1)->GetRightCol();
17508
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 {
17513 resultobj = SWIG_From_int((int)(result));
17514 }
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17522 PyObject *resultobj;
17523 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17524 bool result;
17525 PyObject * obj0 = 0 ;
17526 char *kwnames[] = {
17527 (char *) "self", NULL
17528 };
17529
17530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17532 if (SWIG_arg_fail(1)) SWIG_fail;
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (bool)(arg1)->Selecting();
17536
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17542 }
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj;
17551 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17552 bool result;
17553 PyObject * obj0 = 0 ;
17554 char *kwnames[] = {
17555 (char *) "self", NULL
17556 };
17557
17558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17560 if (SWIG_arg_fail(1)) SWIG_fail;
17561 {
17562 PyThreadState* __tstate = wxPyBeginAllowThreads();
17563 result = (bool)(arg1)->ControlDown();
17564
17565 wxPyEndAllowThreads(__tstate);
17566 if (PyErr_Occurred()) SWIG_fail;
17567 }
17568 {
17569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17570 }
17571 return resultobj;
17572 fail:
17573 return NULL;
17574 }
17575
17576
17577 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17578 PyObject *resultobj;
17579 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17580 bool result;
17581 PyObject * obj0 = 0 ;
17582 char *kwnames[] = {
17583 (char *) "self", NULL
17584 };
17585
17586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17588 if (SWIG_arg_fail(1)) SWIG_fail;
17589 {
17590 PyThreadState* __tstate = wxPyBeginAllowThreads();
17591 result = (bool)(arg1)->MetaDown();
17592
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17598 }
17599 return resultobj;
17600 fail:
17601 return NULL;
17602 }
17603
17604
17605 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17606 PyObject *resultobj;
17607 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17608 bool result;
17609 PyObject * obj0 = 0 ;
17610 char *kwnames[] = {
17611 (char *) "self", NULL
17612 };
17613
17614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17616 if (SWIG_arg_fail(1)) SWIG_fail;
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (bool)(arg1)->ShiftDown();
17620
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17626 }
17627 return resultobj;
17628 fail:
17629 return NULL;
17630 }
17631
17632
17633 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17634 PyObject *resultobj;
17635 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17636 bool result;
17637 PyObject * obj0 = 0 ;
17638 char *kwnames[] = {
17639 (char *) "self", NULL
17640 };
17641
17642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17644 if (SWIG_arg_fail(1)) SWIG_fail;
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (bool)(arg1)->AltDown();
17648
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 {
17653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17654 }
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17662 PyObject *obj;
17663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17664 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17665 Py_INCREF(obj);
17666 return Py_BuildValue((char *)"");
17667 }
17668 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj;
17670 int arg1 ;
17671 wxEventType arg2 ;
17672 wxObject *arg3 = (wxObject *) 0 ;
17673 int arg4 ;
17674 int arg5 ;
17675 wxControl *arg6 = (wxControl *) 0 ;
17676 wxGridEditorCreatedEvent *result;
17677 PyObject * obj0 = 0 ;
17678 PyObject * obj1 = 0 ;
17679 PyObject * obj2 = 0 ;
17680 PyObject * obj3 = 0 ;
17681 PyObject * obj4 = 0 ;
17682 PyObject * obj5 = 0 ;
17683 char *kwnames[] = {
17684 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17685 };
17686
17687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17688 {
17689 arg1 = (int)(SWIG_As_int(obj0));
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 }
17692 {
17693 arg2 = (wxEventType)(SWIG_As_int(obj1));
17694 if (SWIG_arg_fail(2)) SWIG_fail;
17695 }
17696 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17697 if (SWIG_arg_fail(3)) SWIG_fail;
17698 {
17699 arg4 = (int)(SWIG_As_int(obj3));
17700 if (SWIG_arg_fail(4)) SWIG_fail;
17701 }
17702 {
17703 arg5 = (int)(SWIG_As_int(obj4));
17704 if (SWIG_arg_fail(5)) SWIG_fail;
17705 }
17706 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17707 if (SWIG_arg_fail(6)) SWIG_fail;
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17711
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17723 PyObject *resultobj;
17724 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17725 int result;
17726 PyObject * obj0 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = (int)(arg1)->GetRow();
17737
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = SWIG_From_int((int)(result));
17743 }
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17753 int result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "self", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 result = (int)(arg1)->GetCol();
17765
17766 wxPyEndAllowThreads(__tstate);
17767 if (PyErr_Occurred()) SWIG_fail;
17768 }
17769 {
17770 resultobj = SWIG_From_int((int)(result));
17771 }
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj;
17780 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17781 wxControl *result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (wxControl *)(arg1)->GetControl();
17793
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 resultobj = wxPyMake_wxObject(result, 0);
17799 }
17800 return resultobj;
17801 fail:
17802 return NULL;
17803 }
17804
17805
17806 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17807 PyObject *resultobj;
17808 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17809 int arg2 ;
17810 PyObject * obj0 = 0 ;
17811 PyObject * obj1 = 0 ;
17812 char *kwnames[] = {
17813 (char *) "self",(char *) "row", NULL
17814 };
17815
17816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
17817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17818 if (SWIG_arg_fail(1)) SWIG_fail;
17819 {
17820 arg2 = (int)(SWIG_As_int(obj1));
17821 if (SWIG_arg_fail(2)) SWIG_fail;
17822 }
17823 {
17824 PyThreadState* __tstate = wxPyBeginAllowThreads();
17825 (arg1)->SetRow(arg2);
17826
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 Py_INCREF(Py_None); resultobj = Py_None;
17831 return resultobj;
17832 fail:
17833 return NULL;
17834 }
17835
17836
17837 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17838 PyObject *resultobj;
17839 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17840 int arg2 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 char *kwnames[] = {
17844 (char *) "self",(char *) "col", NULL
17845 };
17846
17847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
17848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17849 if (SWIG_arg_fail(1)) SWIG_fail;
17850 {
17851 arg2 = (int)(SWIG_As_int(obj1));
17852 if (SWIG_arg_fail(2)) SWIG_fail;
17853 }
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 (arg1)->SetCol(arg2);
17857
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 Py_INCREF(Py_None); resultobj = Py_None;
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17869 PyObject *resultobj;
17870 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17871 wxControl *arg2 = (wxControl *) 0 ;
17872 PyObject * obj0 = 0 ;
17873 PyObject * obj1 = 0 ;
17874 char *kwnames[] = {
17875 (char *) "self",(char *) "ctrl", NULL
17876 };
17877
17878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 (arg1)->SetControl(arg2);
17886
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 Py_INCREF(Py_None); resultobj = Py_None;
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
17898 PyObject *obj;
17899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17900 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
17901 Py_INCREF(obj);
17902 return Py_BuildValue((char *)"");
17903 }
17904 static PyMethodDef SwigMethods[] = {
17905 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17906 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17907 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17908 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17909 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
17910 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
17911 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17912 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
17913 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17914 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17915 { (char *)"PyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17916 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
17917 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17918 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
17919 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17920 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
17921 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17922 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17923 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17924 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17925 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17926 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
17927 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17928 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
17929 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17930 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
17931 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17932 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
17933 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17934 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
17935 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17936 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
17937 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17938 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17939 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17940 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17941 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17942 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17943 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17944 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
17945 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17946 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17947 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
17948 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17949 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17950 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17951 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17952 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17953 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17954 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17955 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17956 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17957 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
17958 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17959 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17960 { (char *)"PyGridCellEditor_base_SetSize", (PyCFunction) _wrap_PyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17961 { (char *)"PyGridCellEditor_base_Show", (PyCFunction) _wrap_PyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17962 { (char *)"PyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17963 { (char *)"PyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17964 { (char *)"PyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17965 { (char *)"PyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17966 { (char *)"PyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17967 { (char *)"PyGridCellEditor_base_Destroy", (PyCFunction) _wrap_PyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17968 { (char *)"PyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17969 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
17970 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17971 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17972 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
17973 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17974 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17975 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
17976 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17977 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17978 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
17979 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17980 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17981 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
17982 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17983 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17984 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
17985 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17986 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17987 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
17988 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17989 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17990 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
17991 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17992 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17993 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17994 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
17995 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17996 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17997 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
17998 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
17999 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18000 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18001 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18002 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18003 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18004 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18005 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18006 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18007 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18008 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18009 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18010 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18011 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18012 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18013 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18014 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18015 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18016 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18017 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18018 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18019 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18020 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18021 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18022 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18023 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18024 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18025 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18026 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18027 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18028 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18029 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18030 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18031 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18032 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18033 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18034 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18035 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18036 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18037 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18038 { (char *)"PyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18039 { (char *)"PyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18040 { (char *)"PyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18041 { (char *)"PyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18042 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18043 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18044 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18045 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18046 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18047 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18048 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18049 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18050 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18051 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18052 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18053 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18054 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18055 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18056 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18057 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18058 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18059 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18060 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18061 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18062 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18063 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18064 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18065 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18066 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18067 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18068 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18069 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18070 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18071 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18072 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18073 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18074 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18075 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18076 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18077 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18078 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18079 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18080 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18081 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18082 { (char *)"PyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18083 { (char *)"PyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18084 { (char *)"PyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18085 { (char *)"PyGridTableBase_base_Clear", (PyCFunction) _wrap_PyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18086 { (char *)"PyGridTableBase_base_InsertRows", (PyCFunction) _wrap_PyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18087 { (char *)"PyGridTableBase_base_AppendRows", (PyCFunction) _wrap_PyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18088 { (char *)"PyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18089 { (char *)"PyGridTableBase_base_InsertCols", (PyCFunction) _wrap_PyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18090 { (char *)"PyGridTableBase_base_AppendCols", (PyCFunction) _wrap_PyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18091 { (char *)"PyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18092 { (char *)"PyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18093 { (char *)"PyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18094 { (char *)"PyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18095 { (char *)"PyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18096 { (char *)"PyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18097 { (char *)"PyGridTableBase_base_GetAttr", (PyCFunction) _wrap_PyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18098 { (char *)"PyGridTableBase_base_SetAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18099 { (char *)"PyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18100 { (char *)"PyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18101 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18102 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18103 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18104 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18105 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18106 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18107 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18108 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18109 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18110 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18111 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18112 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18113 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18114 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18115 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18116 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18117 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18118 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18119 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18120 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18121 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18122 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18123 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18124 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18125 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18126 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18127 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18128 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18131 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18132 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18134 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18135 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18136 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18137 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18138 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18140 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18143 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18146 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18148 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18150 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18152 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18154 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18177 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18182 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18189 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18191 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18192 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18195 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18198 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18201 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18204 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18207 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18210 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18234 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18246 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18255 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18257 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18259 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18262 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18270 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18281 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18298 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18321 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18323 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18325 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18328 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18329 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18334 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18335 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18338 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18339 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18343 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18345 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18346 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18347 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18348 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18356 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18358 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18359 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18360 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18364 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18365 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18366 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18367 { NULL, NULL, 0, NULL }
18368 };
18369
18370
18371 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18372
18373 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18374 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18375 }
18376 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18377 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18378 }
18379 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18380 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18381 }
18382 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18383 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18384 }
18385 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18386 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18387 }
18388 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18389 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18390 }
18391 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18392 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18393 }
18394 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18395 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18396 }
18397 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18398 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18399 }
18400 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18401 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18402 }
18403 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18404 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18405 }
18406 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18407 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18408 }
18409 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18410 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18411 }
18412 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18413 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18414 }
18415 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18416 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18417 }
18418 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18419 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18420 }
18421 static void *_p_wxGridTo_p_wxPanel(void *x) {
18422 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18423 }
18424 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18425 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18426 }
18427 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18428 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18429 }
18430 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18431 return (void *)((wxPanel *) ((wxPyPanel *) x));
18432 }
18433 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18434 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18435 }
18436 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18437 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18438 }
18439 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18440 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18441 }
18442 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18443 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18444 }
18445 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18446 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18447 }
18448 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18449 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18450 }
18451 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18452 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18453 }
18454 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18455 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18456 }
18457 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18458 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18459 }
18460 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18461 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18462 }
18463 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18464 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18465 }
18466 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18467 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18468 }
18469 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18470 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18471 }
18472 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18473 return (void *)((wxWindow *) ((wxMenuBar *) x));
18474 }
18475 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18476 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18477 }
18478 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18479 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18480 }
18481 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18482 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18483 }
18484 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18485 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18486 }
18487 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18488 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18489 }
18490 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18491 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18492 }
18493 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18494 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18495 }
18496 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18497 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18498 }
18499 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18500 return (void *)((wxWindow *) ((wxPanel *) x));
18501 }
18502 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18503 return (void *)((wxWindow *) ((wxStatusBar *) x));
18504 }
18505 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18506 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18507 }
18508 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18509 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18510 }
18511 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18512 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18513 }
18514 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18515 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18516 }
18517 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18518 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18519 }
18520 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18521 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18522 }
18523 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18524 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18525 }
18526 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18527 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18528 }
18529 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18530 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18531 }
18532 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18533 return (void *)((wxWindow *) ((wxSashWindow *) x));
18534 }
18535 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18536 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18537 }
18538 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18539 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18540 }
18541 static void *_p_wxControlTo_p_wxWindow(void *x) {
18542 return (void *)((wxWindow *) ((wxControl *) x));
18543 }
18544 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18545 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18546 }
18547 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18548 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18549 }
18550 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18551 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18552 }
18553 static void *_p_wxGridTo_p_wxWindow(void *x) {
18554 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18555 }
18556 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18557 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18558 }
18559 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18560 return (void *)((wxWindow *) ((wxPyWindow *) x));
18561 }
18562 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18563 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18564 }
18565 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18566 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18567 }
18568 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18569 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18570 }
18571 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18572 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18573 }
18574 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18575 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18576 }
18577 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18578 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18579 }
18580 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18581 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18582 }
18583 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18584 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18585 }
18586 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18587 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18588 }
18589 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18590 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18591 }
18592 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18593 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18594 }
18595 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18596 return (void *)((wxControl *) ((wxControlWithItems *) x));
18597 }
18598 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18599 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18600 }
18601 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18602 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18603 }
18604 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18605 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18606 }
18607 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18608 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18609 }
18610 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18611 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18612 }
18613 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18614 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18615 }
18616 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18617 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18618 }
18619 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18620 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18621 }
18622 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18623 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18624 }
18625 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18626 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18627 }
18628 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18629 return (void *)((wxEvent *) ((wxPyEvent *) x));
18630 }
18631 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18632 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18633 }
18634 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18635 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18636 }
18637 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18638 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18639 }
18640 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18641 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18642 }
18643 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18644 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18645 }
18646 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18647 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18648 }
18649 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18650 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18651 }
18652 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18653 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18654 }
18655 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18656 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18657 }
18658 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18659 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18660 }
18661 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18662 return (void *)((wxEvent *) ((wxMoveEvent *) 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_wxIdleEventTo_p_wxObject(void *x) {
18905 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
18906 }
18907 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
18908 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
18909 }
18910 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
18911 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
18912 }
18913 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
18914 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
18915 }
18916 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
18917 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
18918 }
18919 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
18920 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
18921 }
18922 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
18923 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
18924 }
18925 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
18926 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
18927 }
18928 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
18929 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18930 }
18931 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
18932 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
18933 }
18934 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
18935 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
18936 }
18937 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
18938 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
18939 }
18940 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
18941 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
18942 }
18943 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
18944 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
18945 }
18946 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
18947 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
18948 }
18949 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
18950 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
18951 }
18952 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
18953 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
18954 }
18955 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
18956 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
18957 }
18958 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
18959 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
18960 }
18961 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
18962 return (void *)((wxObject *) ((wxImageHandler *) x));
18963 }
18964 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
18965 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
18966 }
18967 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
18968 return (void *)((wxObject *) ((wxEvtHandler *) x));
18969 }
18970 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
18971 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
18972 }
18973 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
18974 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18975 }
18976 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
18977 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18978 }
18979 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
18980 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18981 }
18982 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
18983 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
18984 }
18985 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
18986 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
18987 }
18988 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
18989 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18990 }
18991 static void *_p_wxImageTo_p_wxObject(void *x) {
18992 return (void *)((wxObject *) ((wxImage *) x));
18993 }
18994 static void *_p_wxFrameTo_p_wxObject(void *x) {
18995 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
18996 }
18997 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
18998 return (void *)((wxObject *) ((wxPyPrintout *) x));
18999 }
19000 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19001 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19002 }
19003 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19004 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19005 }
19006 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19007 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19008 }
19009 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19010 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19011 }
19012 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19013 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19014 }
19015 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19016 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19017 }
19018 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19019 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19020 }
19021 static void *_p_wxWindowTo_p_wxObject(void *x) {
19022 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19023 }
19024 static void *_p_wxMenuTo_p_wxObject(void *x) {
19025 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19026 }
19027 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19028 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19029 }
19030 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19031 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19032 }
19033 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19034 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19035 }
19036 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19037 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19038 }
19039 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19040 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19041 }
19042 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19043 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19044 }
19045 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19046 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19047 }
19048 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19049 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19050 }
19051 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19052 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19053 }
19054 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19055 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19056 }
19057 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19058 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19059 }
19060 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19061 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19062 }
19063 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19064 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19065 }
19066 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19067 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19068 }
19069 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19070 return (void *)((wxObject *) ((wxPrintPreview *) x));
19071 }
19072 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19073 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19074 }
19075 static void *_p_wxPanelTo_p_wxObject(void *x) {
19076 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19077 }
19078 static void *_p_wxDialogTo_p_wxObject(void *x) {
19079 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19080 }
19081 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19083 }
19084 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19085 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19086 }
19087 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19088 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19089 }
19090 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19091 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19092 }
19093 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19094 return (void *)((wxObject *) ((wxPrintDialog *) x));
19095 }
19096 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19097 return (void *)((wxObject *) ((wxFileSystem *) x));
19098 }
19099 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19100 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19101 }
19102 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19103 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19104 }
19105 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19106 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19107 }
19108 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19109 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19110 }
19111 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19112 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19113 }
19114 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19115 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19116 }
19117 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19118 return (void *)((wxObject *) ((wxGridTableBase *) x));
19119 }
19120 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19121 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19122 }
19123 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19125 }
19126 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19127 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19128 }
19129 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19130 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19131 }
19132 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19133 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19134 }
19135 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19136 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19137 }
19138 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19139 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19140 }
19141 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19142 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19143 }
19144 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19145 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19146 }
19147 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19148 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19149 }
19150 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19151 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19152 }
19153 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19154 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19155 }
19156 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19157 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19158 }
19159 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19160 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19161 }
19162 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19163 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19164 }
19165 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19166 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19167 }
19168 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19169 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19170 }
19171 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19172 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19173 }
19174 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19175 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19176 }
19177 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19178 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19179 }
19180 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19181 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19182 }
19183 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19184 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19185 }
19186 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19187 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19188 }
19189 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19190 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19191 }
19192 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19193 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19194 }
19195 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19196 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19197 }
19198 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19199 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19200 }
19201 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19202 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19203 }
19204 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19205 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19206 }
19207 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19208 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19209 }
19210 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19211 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19212 }
19213 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19214 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19215 }
19216 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19217 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19218 }
19219 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19220 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19221 }
19222 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19223 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19224 }
19225 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19226 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19227 }
19228 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19229 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19230 }
19231 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19232 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19233 }
19234 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19235 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19236 }
19237 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19238 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19239 }
19240 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19241 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19242 }
19243 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19244 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19245 }
19246 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19247 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19248 }
19249 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19250 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19251 }
19252 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19253 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19254 }
19255 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19256 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19257 }
19258 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19259 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19260 }
19261 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19262 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19263 }
19264 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19265 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19266 }
19267 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19268 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19269 }
19270 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19271 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19272 }
19273 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19274 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19275 }
19276 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19277 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19278 }
19279 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19280 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19281 }
19282 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19283 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19284 }
19285 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19286 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19287 }
19288 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19289 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19290 }
19291 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19292 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19293 }
19294 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19295 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19296 }
19297 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19298 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19299 }
19300 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19301 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19302 }
19303 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19304 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19305 }
19306 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19307 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19308 }
19309 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19310 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19311 }
19312 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19313 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19314 }
19315 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19316 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19317 }
19318 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19319 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19320 }
19321 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19322 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19323 }
19324 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19325 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19326 }
19327 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19328 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19329 }
19330 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19331 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19332 }
19333 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19334 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19335 }
19336 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19337 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19338 }
19339 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19340 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19341 }
19342 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19343 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19344 }
19345 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19346 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19347 }
19348 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19349 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19350 }
19351 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19352 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19353 }
19354 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19355 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19356 }
19357 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19358 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19359 }
19360 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19361 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19362 }
19363 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19364 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19365 }
19366 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19367 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19368 }
19369 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19370 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19371 }
19372 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19373 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19374 }
19375 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19376 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19377 }
19378 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19379 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19380 }
19381 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19382 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19383 }
19384 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19385 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19386 }
19387 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19388 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19389 }
19390 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19391 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19392 }
19393 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19394 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19395 }
19396 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19397 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19398 }
19399 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}};
19400 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}};
19401 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}};
19402 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}};
19403 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}};
19404 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}};
19405 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}};
19406 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}};
19407 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}};
19408 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}};
19409 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}};
19410 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}};
19411 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}};
19412 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}};
19413 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}};
19414 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}};
19415 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}};
19416 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}};
19417 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}};
19418 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}};
19419 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}};
19420 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}};
19421 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}};
19422 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}};
19423 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}};
19424 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}};
19425 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}};
19426 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_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}};
19427 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_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_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_wxANIHandler", _p_wxANIHandlerTo_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_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}};
19428 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}};
19429 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}};
19430 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}};
19431 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}};
19432 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}};
19433 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}};
19434 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}};
19435 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}};
19436 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}};
19437 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}};
19438 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}};
19439 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}};
19440 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}};
19441 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}};
19442 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}};
19443 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}};
19444 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}};
19445 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}};
19446 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}};
19447 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}};
19448 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}};
19449 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}};
19450 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}};
19451 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}};
19452 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_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}};
19453 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}};
19454 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}};
19455 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}};
19456 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}};
19457 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}};
19458 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}};
19459 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}};
19460 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}};
19461
19462 static swig_type_info *swig_types_initial[] = {
19463 _swigt__p_wxGridCellNumberRenderer,
19464 _swigt__p_wxPyGridCellRenderer,
19465 _swigt__p_wxGridCellRenderer,
19466 _swigt__p_wxGridCellStringRenderer,
19467 _swigt__p_wxGridCellAttr,
19468 _swigt__p_wxGridCellFloatRenderer,
19469 _swigt__p_wxGridCellBoolRenderer,
19470 _swigt__p_wxGridCellDateTimeRenderer,
19471 _swigt__p_wxGridCellEnumRenderer,
19472 _swigt__p_wxGridCellAutoWrapStringRenderer,
19473 _swigt__p_wxColour,
19474 _swigt__p_wxDC,
19475 _swigt__p_form_ops_t,
19476 _swigt__p_wxDuplexMode,
19477 _swigt__p_wxGridTableMessage,
19478 _swigt__p_wxGrid,
19479 _swigt__p_wxVisualAttributes,
19480 _swigt__p_char,
19481 _swigt__p_wxPanel,
19482 _swigt__p_wxNotifyEvent,
19483 _swigt__p_wxGridRangeSelectEvent,
19484 _swigt__p_wxSize,
19485 _swigt__p_wxGridCellCoords,
19486 _swigt__p_wxScrolledWindow,
19487 _swigt__p_wxWindow,
19488 _swigt__p_wxFont,
19489 _swigt__p_wxControl,
19490 _swigt__p_wxEvent,
19491 _swigt__p_wxObject,
19492 _swigt__p_wxGridSizeEvent,
19493 _swigt__p_wxRect,
19494 _swigt__p_long,
19495 _swigt__p_wxPaperSize,
19496 _swigt__p_unsigned_int,
19497 _swigt__unsigned_int,
19498 _swigt__p_wxString,
19499 _swigt__p_wxEvtHandler,
19500 _swigt__p_wxPoint,
19501 _swigt__p_wxGridEvent,
19502 _swigt__p_wxGridEditorCreatedEvent,
19503 _swigt__p_wxGridTableBase,
19504 _swigt__p_wxGridCellEditor,
19505 _swigt__p_wxGridCellTextEditor,
19506 _swigt__p_wxPyGridCellEditor,
19507 _swigt__p_wxGridCellNumberEditor,
19508 _swigt__p_wxGridCellFloatEditor,
19509 _swigt__p_wxGridCellBoolEditor,
19510 _swigt__p_wxPyGridTableBase,
19511 _swigt__p_wxGridStringTable,
19512 _swigt__p_unsigned_char,
19513 _swigt__std__ptrdiff_t,
19514 _swigt__ptrdiff_t,
19515 _swigt__p_wxArrayString,
19516 _swigt__p_wxCommandEvent,
19517 _swigt__p_int,
19518 _swigt__p_wxGridCellAttrProvider,
19519 _swigt__p_wxGridCellChoiceEditor,
19520 _swigt__p_wxKeyEvent,
19521 _swigt__p_wxGridCellEnumEditor,
19522 _swigt__p_wxGridCellAutoWrapStringEditor,
19523 _swigt__p_wxPyGridCellAttrProvider,
19524 _swigt__p_unsigned_long,
19525 0
19526 };
19527
19528
19529 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
19530
19531 static swig_const_info swig_const_table[] = {
19532 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19533 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
19534 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19535 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
19536 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
19537 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19538 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19539 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
19540 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
19541 {0, 0, 0, 0.0, 0, 0}};
19542
19543 #ifdef __cplusplus
19544 }
19545 #endif
19546
19547
19548 #ifdef __cplusplus
19549 extern "C" {
19550 #endif
19551
19552 /* Python-specific SWIG API */
19553 #define SWIG_newvarlink() SWIG_Python_newvarlink()
19554 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
19555 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
19556
19557 /* -----------------------------------------------------------------------------
19558 * global variable support code.
19559 * ----------------------------------------------------------------------------- */
19560
19561 typedef struct swig_globalvar {
19562 char *name; /* Name of global variable */
19563 PyObject *(*get_attr)(); /* Return the current value */
19564 int (*set_attr)(PyObject *); /* Set the value */
19565 struct swig_globalvar *next;
19566 } swig_globalvar;
19567
19568 typedef struct swig_varlinkobject {
19569 PyObject_HEAD
19570 swig_globalvar *vars;
19571 } swig_varlinkobject;
19572
19573 static PyObject *
19574 swig_varlink_repr(swig_varlinkobject *v) {
19575 v = v;
19576 return PyString_FromString("<Swig global variables>");
19577 }
19578
19579 static int
19580 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
19581 swig_globalvar *var;
19582 flags = flags;
19583 fprintf(fp,"Swig global variables { ");
19584 for (var = v->vars; var; var=var->next) {
19585 fprintf(fp,"%s", var->name);
19586 if (var->next) fprintf(fp,", ");
19587 }
19588 fprintf(fp," }\n");
19589 return 0;
19590 }
19591
19592 static PyObject *
19593 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
19594 swig_globalvar *var = v->vars;
19595 while (var) {
19596 if (strcmp(var->name,n) == 0) {
19597 return (*var->get_attr)();
19598 }
19599 var = var->next;
19600 }
19601 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19602 return NULL;
19603 }
19604
19605 static int
19606 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
19607 swig_globalvar *var = v->vars;
19608 while (var) {
19609 if (strcmp(var->name,n) == 0) {
19610 return (*var->set_attr)(p);
19611 }
19612 var = var->next;
19613 }
19614 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19615 return 1;
19616 }
19617
19618 static PyTypeObject varlinktype = {
19619 PyObject_HEAD_INIT(0)
19620 0, /* Number of items in variable part (ob_size) */
19621 (char *)"swigvarlink", /* Type name (tp_name) */
19622 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
19623 0, /* Itemsize (tp_itemsize) */
19624 0, /* Deallocator (tp_dealloc) */
19625 (printfunc) swig_varlink_print, /* Print (tp_print) */
19626 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
19627 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
19628 0, /* tp_compare */
19629 (reprfunc) swig_varlink_repr, /* tp_repr */
19630 0, /* tp_as_number */
19631 0, /* tp_as_sequence */
19632 0, /* tp_as_mapping */
19633 0, /* tp_hash */
19634 0, /* tp_call */
19635 0, /* tp_str */
19636 0, /* tp_getattro */
19637 0, /* tp_setattro */
19638 0, /* tp_as_buffer */
19639 0, /* tp_flags */
19640 0, /* tp_doc */
19641 #if PY_VERSION_HEX >= 0x02000000
19642 0, /* tp_traverse */
19643 0, /* tp_clear */
19644 #endif
19645 #if PY_VERSION_HEX >= 0x02010000
19646 0, /* tp_richcompare */
19647 0, /* tp_weaklistoffset */
19648 #endif
19649 #if PY_VERSION_HEX >= 0x02020000
19650 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
19651 #endif
19652 #if PY_VERSION_HEX >= 0x02030000
19653 0, /* tp_del */
19654 #endif
19655 #ifdef COUNT_ALLOCS
19656 0,0,0,0 /* tp_alloc -> tp_next */
19657 #endif
19658 };
19659
19660 /* Create a variable linking object for use later */
19661 static PyObject *
19662 SWIG_Python_newvarlink(void) {
19663 swig_varlinkobject *result = 0;
19664 result = PyMem_NEW(swig_varlinkobject,1);
19665 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
19666 result->ob_type = &varlinktype;
19667 result->vars = 0;
19668 result->ob_refcnt = 0;
19669 Py_XINCREF((PyObject *) result);
19670 return ((PyObject*) result);
19671 }
19672
19673 static void
19674 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
19675 swig_varlinkobject *v;
19676 swig_globalvar *gv;
19677 v= (swig_varlinkobject *) p;
19678 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
19679 gv->name = (char *) malloc(strlen(name)+1);
19680 strcpy(gv->name,name);
19681 gv->get_attr = get_attr;
19682 gv->set_attr = set_attr;
19683 gv->next = v->vars;
19684 v->vars = gv;
19685 }
19686
19687 /* -----------------------------------------------------------------------------
19688 * constants/methods manipulation
19689 * ----------------------------------------------------------------------------- */
19690
19691 /* Install Constants */
19692 static void
19693 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
19694 PyObject *obj = 0;
19695 size_t i;
19696 for (i = 0; constants[i].type; i++) {
19697 switch(constants[i].type) {
19698 case SWIG_PY_INT:
19699 obj = PyInt_FromLong(constants[i].lvalue);
19700 break;
19701 case SWIG_PY_FLOAT:
19702 obj = PyFloat_FromDouble(constants[i].dvalue);
19703 break;
19704 case SWIG_PY_STRING:
19705 if (constants[i].pvalue) {
19706 obj = PyString_FromString((char *) constants[i].pvalue);
19707 } else {
19708 Py_INCREF(Py_None);
19709 obj = Py_None;
19710 }
19711 break;
19712 case SWIG_PY_POINTER:
19713 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
19714 break;
19715 case SWIG_PY_BINARY:
19716 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
19717 break;
19718 default:
19719 obj = 0;
19720 break;
19721 }
19722 if (obj) {
19723 PyDict_SetItemString(d,constants[i].name,obj);
19724 Py_DECREF(obj);
19725 }
19726 }
19727 }
19728
19729 /* -----------------------------------------------------------------------------*/
19730 /* Fix SwigMethods to carry the callback ptrs when needed */
19731 /* -----------------------------------------------------------------------------*/
19732
19733 static void
19734 SWIG_Python_FixMethods(PyMethodDef *methods,
19735 swig_const_info *const_table,
19736 swig_type_info **types,
19737 swig_type_info **types_initial) {
19738 size_t i;
19739 for (i = 0; methods[i].ml_name; ++i) {
19740 char *c = methods[i].ml_doc;
19741 if (c && (c = strstr(c, "swig_ptr: "))) {
19742 int j;
19743 swig_const_info *ci = 0;
19744 char *name = c + 10;
19745 for (j = 0; const_table[j].type; j++) {
19746 if (strncmp(const_table[j].name, name,
19747 strlen(const_table[j].name)) == 0) {
19748 ci = &(const_table[j]);
19749 break;
19750 }
19751 }
19752 if (ci) {
19753 size_t shift = (ci->ptype) - types;
19754 swig_type_info *ty = types_initial[shift];
19755 size_t ldoc = (c - methods[i].ml_doc);
19756 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
19757 char *ndoc = (char*)malloc(ldoc + lptr + 10);
19758 char *buff = ndoc;
19759 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
19760 strncpy(buff, methods[i].ml_doc, ldoc);
19761 buff += ldoc;
19762 strncpy(buff, "swig_ptr: ", 10);
19763 buff += 10;
19764 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
19765 methods[i].ml_doc = ndoc;
19766 }
19767 }
19768 }
19769 }
19770
19771 /* -----------------------------------------------------------------------------*
19772 * Initialize type list
19773 * -----------------------------------------------------------------------------*/
19774
19775 #if PY_MAJOR_VERSION < 2
19776 /* PyModule_AddObject function was introduced in Python 2.0. The following function
19777 is copied out of Python/modsupport.c in python version 2.3.4 */
19778 static int
19779 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
19780 {
19781 PyObject *dict;
19782 if (!PyModule_Check(m)) {
19783 PyErr_SetString(PyExc_TypeError,
19784 "PyModule_AddObject() needs module as first arg");
19785 return -1;
19786 }
19787 if (!o) {
19788 PyErr_SetString(PyExc_TypeError,
19789 "PyModule_AddObject() needs non-NULL value");
19790 return -1;
19791 }
19792
19793 dict = PyModule_GetDict(m);
19794 if (dict == NULL) {
19795 /* Internal error -- modules must have a dict! */
19796 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
19797 PyModule_GetName(m));
19798 return -1;
19799 }
19800 if (PyDict_SetItemString(dict, name, o))
19801 return -1;
19802 Py_DECREF(o);
19803 return 0;
19804 }
19805 #endif
19806
19807 static swig_type_info **
19808 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
19809 static PyMethodDef swig_empty_runtime_method_table[] = {
19810 {
19811 NULL, NULL, 0, NULL
19812 }
19813 };/* Sentinel */
19814
19815 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
19816 swig_empty_runtime_method_table);
19817 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
19818 if (pointer && module) {
19819 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
19820 }
19821 return type_list_handle;
19822 }
19823
19824 static swig_type_info **
19825 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
19826 swig_type_info **type_pointer;
19827
19828 /* first check if module already created */
19829 type_pointer = SWIG_Python_GetTypeListHandle();
19830 if (type_pointer) {
19831 return type_pointer;
19832 } else {
19833 /* create a new module and variable */
19834 return SWIG_Python_SetTypeListHandle(type_list_handle);
19835 }
19836 }
19837
19838 #ifdef __cplusplus
19839 }
19840 #endif
19841
19842 /* -----------------------------------------------------------------------------*
19843 * Partial Init method
19844 * -----------------------------------------------------------------------------*/
19845
19846 #ifdef SWIG_LINK_RUNTIME
19847 #ifdef __cplusplus
19848 extern "C"
19849 #endif
19850 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
19851 #endif
19852
19853 #ifdef __cplusplus
19854 extern "C"
19855 #endif
19856 SWIGEXPORT(void) SWIG_init(void) {
19857 static PyObject *SWIG_globals = 0;
19858 static int typeinit = 0;
19859 PyObject *m, *d;
19860 int i;
19861 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
19862
19863 /* Fix SwigMethods to carry the callback ptrs when needed */
19864 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
19865
19866 m = Py_InitModule((char *) SWIG_name, SwigMethods);
19867 d = PyModule_GetDict(m);
19868
19869 if (!typeinit) {
19870 #ifdef SWIG_LINK_RUNTIME
19871 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
19872 #else
19873 # ifndef SWIG_STATIC_RUNTIME
19874 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
19875 # endif
19876 #endif
19877 for (i = 0; swig_types_initial[i]; i++) {
19878 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
19879 }
19880 typeinit = 1;
19881 }
19882 SWIG_InstallConstants(d,swig_const_table);
19883
19884 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
19885 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
19886 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
19887 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
19888 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
19889 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
19890 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
19891 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
19892 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
19893 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
19894 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
19895 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
19896 {
19897 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_ROWS)));
19898 }
19899 {
19900 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_COLS)));
19901 }
19902 {
19903 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_HEIGHT)));
19904 }
19905 {
19906 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_COL_WIDTH)));
19907 }
19908 {
19909 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
19910 }
19911 {
19912 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
19913 }
19914 {
19915 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int((int)(wxGRID_LABEL_EDGE_ZONE)));
19916 }
19917 {
19918 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_MIN_ROW_HEIGHT)));
19919 }
19920 {
19921 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int((int)(wxGRID_MIN_COL_WIDTH)));
19922 }
19923 {
19924 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
19925 }
19926 {
19927 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int((int)(wxGridCellAttr::Any)));
19928 }
19929 {
19930 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int((int)(wxGridCellAttr::Default)));
19931 }
19932 {
19933 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int((int)(wxGridCellAttr::Cell)));
19934 }
19935 {
19936 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int((int)(wxGridCellAttr::Row)));
19937 }
19938 {
19939 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int((int)(wxGridCellAttr::Col)));
19940 }
19941 {
19942 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int((int)(wxGridCellAttr::Merged)));
19943 }
19944 {
19945 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
19946 }
19947 {
19948 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
19949 }
19950 {
19951 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
19952 }
19953 {
19954 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
19955 }
19956 {
19957 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
19958 }
19959 {
19960 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
19961 }
19962 {
19963 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
19964 }
19965 {
19966 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
19967 }
19968 {
19969 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int((int)(wxGrid::wxGridSelectCells)));
19970 }
19971 {
19972 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int((int)(wxGrid::wxGridSelectRows)));
19973 }
19974 {
19975 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int((int)(wxGrid::wxGridSelectColumns)));
19976 }
19977 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
19978 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
19979 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
19980 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
19981 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
19982 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
19983 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
19984 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
19985 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
19986 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
19987 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
19988 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
19989 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
19990 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
19991 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
19992 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
19993 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
19994
19995
19996 }
19997
wxWidgets (Impactor)