]> 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
wxLongLong to wxString operators.
[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 wxPyDateTimeFormatStr(wxT("%c"));
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_DateTimeFormatStr_set(PyObject *) {
2641 PyErr_SetString(PyExc_TypeError,"Variable DateTimeFormatStr is read-only.");
2642 return 1;
2643 }
2644
2645
2646 static PyObject *_wrap_DateTimeFormatStr_get(void) {
2647 PyObject *pyobj;
2648
2649 {
2650 #if wxUSE_UNICODE
2651 pyobj = PyUnicode_FromWideChar((&wxPyDateTimeFormatStr)->c_str(), (&wxPyDateTimeFormatStr)->Len());
2652 #else
2653 pyobj = PyString_FromStringAndSize((&wxPyDateTimeFormatStr)->c_str(), (&wxPyDateTimeFormatStr)->Len());
2654 #endif
2655 }
2656 return pyobj;
2657 }
2658
2659
2660 static int _wrap_GridNoCellCoords_set(PyObject *) {
2661 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2662 return 1;
2663 }
2664
2665
2666 static PyObject *_wrap_GridNoCellCoords_get(void) {
2667 PyObject *pyobj;
2668
2669 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2670 return pyobj;
2671 }
2672
2673
2674 static int _wrap_GridNoCellRect_set(PyObject *) {
2675 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2676 return 1;
2677 }
2678
2679
2680 static PyObject *_wrap_GridNoCellRect_get(void) {
2681 PyObject *pyobj;
2682
2683 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2684 return pyobj;
2685 }
2686
2687
2688 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2689 PyObject *resultobj;
2690 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2691 PyObject *arg2 = (PyObject *) 0 ;
2692 PyObject * obj0 = 0 ;
2693 PyObject * obj1 = 0 ;
2694 char *kwnames[] = {
2695 (char *) "self",(char *) "_self", NULL
2696 };
2697
2698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2700 if (SWIG_arg_fail(1)) SWIG_fail;
2701 arg2 = obj1;
2702 {
2703 PyThreadState* __tstate = wxPyBeginAllowThreads();
2704 wxGridCellRenderer__setOORInfo(arg1,arg2);
2705
2706 wxPyEndAllowThreads(__tstate);
2707 if (PyErr_Occurred()) SWIG_fail;
2708 }
2709 Py_INCREF(Py_None); resultobj = Py_None;
2710 return resultobj;
2711 fail:
2712 return NULL;
2713 }
2714
2715
2716 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2717 PyObject *resultobj;
2718 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2719 wxString *arg2 = 0 ;
2720 bool temp2 = false ;
2721 PyObject * obj0 = 0 ;
2722 PyObject * obj1 = 0 ;
2723 char *kwnames[] = {
2724 (char *) "self",(char *) "params", NULL
2725 };
2726
2727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2729 if (SWIG_arg_fail(1)) SWIG_fail;
2730 {
2731 arg2 = wxString_in_helper(obj1);
2732 if (arg2 == NULL) SWIG_fail;
2733 temp2 = true;
2734 }
2735 {
2736 PyThreadState* __tstate = wxPyBeginAllowThreads();
2737 (arg1)->SetParameters((wxString const &)*arg2);
2738
2739 wxPyEndAllowThreads(__tstate);
2740 if (PyErr_Occurred()) SWIG_fail;
2741 }
2742 Py_INCREF(Py_None); resultobj = Py_None;
2743 {
2744 if (temp2)
2745 delete arg2;
2746 }
2747 return resultobj;
2748 fail:
2749 {
2750 if (temp2)
2751 delete arg2;
2752 }
2753 return NULL;
2754 }
2755
2756
2757 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2758 PyObject *resultobj;
2759 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2760 PyObject * obj0 = 0 ;
2761 char *kwnames[] = {
2762 (char *) "self", NULL
2763 };
2764
2765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2767 if (SWIG_arg_fail(1)) SWIG_fail;
2768 {
2769 PyThreadState* __tstate = wxPyBeginAllowThreads();
2770 (arg1)->IncRef();
2771
2772 wxPyEndAllowThreads(__tstate);
2773 if (PyErr_Occurred()) SWIG_fail;
2774 }
2775 Py_INCREF(Py_None); resultobj = Py_None;
2776 return resultobj;
2777 fail:
2778 return NULL;
2779 }
2780
2781
2782 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2783 PyObject *resultobj;
2784 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2785 PyObject * obj0 = 0 ;
2786 char *kwnames[] = {
2787 (char *) "self", NULL
2788 };
2789
2790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2792 if (SWIG_arg_fail(1)) SWIG_fail;
2793 {
2794 PyThreadState* __tstate = wxPyBeginAllowThreads();
2795 (arg1)->DecRef();
2796
2797 wxPyEndAllowThreads(__tstate);
2798 if (PyErr_Occurred()) SWIG_fail;
2799 }
2800 Py_INCREF(Py_None); resultobj = Py_None;
2801 return resultobj;
2802 fail:
2803 return NULL;
2804 }
2805
2806
2807 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
2808 PyObject *resultobj;
2809 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2810 wxGrid *arg2 = 0 ;
2811 wxGridCellAttr *arg3 = 0 ;
2812 wxDC *arg4 = 0 ;
2813 wxRect *arg5 = 0 ;
2814 int arg6 ;
2815 int arg7 ;
2816 bool arg8 ;
2817 wxRect temp5 ;
2818 PyObject * obj0 = 0 ;
2819 PyObject * obj1 = 0 ;
2820 PyObject * obj2 = 0 ;
2821 PyObject * obj3 = 0 ;
2822 PyObject * obj4 = 0 ;
2823 PyObject * obj5 = 0 ;
2824 PyObject * obj6 = 0 ;
2825 PyObject * obj7 = 0 ;
2826 char *kwnames[] = {
2827 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
2828 };
2829
2830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(1)) SWIG_fail;
2833 {
2834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2835 if (SWIG_arg_fail(2)) SWIG_fail;
2836 if (arg2 == NULL) {
2837 SWIG_null_ref("wxGrid");
2838 }
2839 if (SWIG_arg_fail(2)) SWIG_fail;
2840 }
2841 {
2842 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2843 if (SWIG_arg_fail(3)) SWIG_fail;
2844 if (arg3 == NULL) {
2845 SWIG_null_ref("wxGridCellAttr");
2846 }
2847 if (SWIG_arg_fail(3)) SWIG_fail;
2848 }
2849 {
2850 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2851 if (SWIG_arg_fail(4)) SWIG_fail;
2852 if (arg4 == NULL) {
2853 SWIG_null_ref("wxDC");
2854 }
2855 if (SWIG_arg_fail(4)) SWIG_fail;
2856 }
2857 {
2858 arg5 = &temp5;
2859 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
2860 }
2861 {
2862 arg6 = (int)(SWIG_As_int(obj5));
2863 if (SWIG_arg_fail(6)) SWIG_fail;
2864 }
2865 {
2866 arg7 = (int)(SWIG_As_int(obj6));
2867 if (SWIG_arg_fail(7)) SWIG_fail;
2868 }
2869 {
2870 arg8 = (bool)(SWIG_As_bool(obj7));
2871 if (SWIG_arg_fail(8)) SWIG_fail;
2872 }
2873 {
2874 PyThreadState* __tstate = wxPyBeginAllowThreads();
2875 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
2876
2877 wxPyEndAllowThreads(__tstate);
2878 if (PyErr_Occurred()) SWIG_fail;
2879 }
2880 Py_INCREF(Py_None); resultobj = Py_None;
2881 return resultobj;
2882 fail:
2883 return NULL;
2884 }
2885
2886
2887 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
2888 PyObject *resultobj;
2889 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2890 wxGrid *arg2 = 0 ;
2891 wxGridCellAttr *arg3 = 0 ;
2892 wxDC *arg4 = 0 ;
2893 int arg5 ;
2894 int arg6 ;
2895 wxSize result;
2896 PyObject * obj0 = 0 ;
2897 PyObject * obj1 = 0 ;
2898 PyObject * obj2 = 0 ;
2899 PyObject * obj3 = 0 ;
2900 PyObject * obj4 = 0 ;
2901 PyObject * obj5 = 0 ;
2902 char *kwnames[] = {
2903 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
2904 };
2905
2906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2908 if (SWIG_arg_fail(1)) SWIG_fail;
2909 {
2910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2911 if (SWIG_arg_fail(2)) SWIG_fail;
2912 if (arg2 == NULL) {
2913 SWIG_null_ref("wxGrid");
2914 }
2915 if (SWIG_arg_fail(2)) SWIG_fail;
2916 }
2917 {
2918 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2919 if (SWIG_arg_fail(3)) SWIG_fail;
2920 if (arg3 == NULL) {
2921 SWIG_null_ref("wxGridCellAttr");
2922 }
2923 if (SWIG_arg_fail(3)) SWIG_fail;
2924 }
2925 {
2926 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2927 if (SWIG_arg_fail(4)) SWIG_fail;
2928 if (arg4 == NULL) {
2929 SWIG_null_ref("wxDC");
2930 }
2931 if (SWIG_arg_fail(4)) SWIG_fail;
2932 }
2933 {
2934 arg5 = (int)(SWIG_As_int(obj4));
2935 if (SWIG_arg_fail(5)) SWIG_fail;
2936 }
2937 {
2938 arg6 = (int)(SWIG_As_int(obj5));
2939 if (SWIG_arg_fail(6)) SWIG_fail;
2940 }
2941 {
2942 PyThreadState* __tstate = wxPyBeginAllowThreads();
2943 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
2944
2945 wxPyEndAllowThreads(__tstate);
2946 if (PyErr_Occurred()) SWIG_fail;
2947 }
2948 {
2949 wxSize * resultptr;
2950 resultptr = new wxSize((wxSize &)(result));
2951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2952 }
2953 return resultobj;
2954 fail:
2955 return NULL;
2956 }
2957
2958
2959 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
2960 PyObject *resultobj;
2961 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2962 wxGridCellRenderer *result;
2963 PyObject * obj0 = 0 ;
2964 char *kwnames[] = {
2965 (char *) "self", NULL
2966 };
2967
2968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
2969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2970 if (SWIG_arg_fail(1)) SWIG_fail;
2971 {
2972 PyThreadState* __tstate = wxPyBeginAllowThreads();
2973 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
2974
2975 wxPyEndAllowThreads(__tstate);
2976 if (PyErr_Occurred()) SWIG_fail;
2977 }
2978 {
2979 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
2980 }
2981 return resultobj;
2982 fail:
2983 return NULL;
2984 }
2985
2986
2987 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
2988 PyObject *obj;
2989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2990 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
2991 Py_INCREF(obj);
2992 return Py_BuildValue((char *)"");
2993 }
2994 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
2995 PyObject *resultobj;
2996 wxPyGridCellRenderer *result;
2997 char *kwnames[] = {
2998 NULL
2999 };
3000
3001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
3002 {
3003 PyThreadState* __tstate = wxPyBeginAllowThreads();
3004 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3005
3006 wxPyEndAllowThreads(__tstate);
3007 if (PyErr_Occurred()) SWIG_fail;
3008 }
3009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3019 PyObject *arg2 = (PyObject *) 0 ;
3020 PyObject *arg3 = (PyObject *) 0 ;
3021 PyObject * obj0 = 0 ;
3022 PyObject * obj1 = 0 ;
3023 PyObject * obj2 = 0 ;
3024 char *kwnames[] = {
3025 (char *) "self",(char *) "self",(char *) "_class", NULL
3026 };
3027
3028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3030 if (SWIG_arg_fail(1)) SWIG_fail;
3031 arg2 = obj1;
3032 arg3 = obj2;
3033 {
3034 PyThreadState* __tstate = wxPyBeginAllowThreads();
3035 (arg1)->_setCallbackInfo(arg2,arg3);
3036
3037 wxPyEndAllowThreads(__tstate);
3038 if (PyErr_Occurred()) SWIG_fail;
3039 }
3040 Py_INCREF(Py_None); resultobj = Py_None;
3041 return resultobj;
3042 fail:
3043 return NULL;
3044 }
3045
3046
3047 static PyObject *_wrap_PyGridCellRenderer_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3048 PyObject *resultobj;
3049 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3050 wxString *arg2 = 0 ;
3051 bool temp2 = false ;
3052 PyObject * obj0 = 0 ;
3053 PyObject * obj1 = 0 ;
3054 char *kwnames[] = {
3055 (char *) "self",(char *) "params", NULL
3056 };
3057
3058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3060 if (SWIG_arg_fail(1)) SWIG_fail;
3061 {
3062 arg2 = wxString_in_helper(obj1);
3063 if (arg2 == NULL) SWIG_fail;
3064 temp2 = true;
3065 }
3066 {
3067 PyThreadState* __tstate = wxPyBeginAllowThreads();
3068 (arg1)->base_SetParameters((wxString const &)*arg2);
3069
3070 wxPyEndAllowThreads(__tstate);
3071 if (PyErr_Occurred()) SWIG_fail;
3072 }
3073 Py_INCREF(Py_None); resultobj = Py_None;
3074 {
3075 if (temp2)
3076 delete arg2;
3077 }
3078 return resultobj;
3079 fail:
3080 {
3081 if (temp2)
3082 delete arg2;
3083 }
3084 return NULL;
3085 }
3086
3087
3088 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3089 PyObject *obj;
3090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3091 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3092 Py_INCREF(obj);
3093 return Py_BuildValue((char *)"");
3094 }
3095 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3096 PyObject *resultobj;
3097 wxGridCellStringRenderer *result;
3098 char *kwnames[] = {
3099 NULL
3100 };
3101
3102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3103 {
3104 PyThreadState* __tstate = wxPyBeginAllowThreads();
3105 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3106
3107 wxPyEndAllowThreads(__tstate);
3108 if (PyErr_Occurred()) SWIG_fail;
3109 }
3110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3111 return resultobj;
3112 fail:
3113 return NULL;
3114 }
3115
3116
3117 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3118 PyObject *obj;
3119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3120 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3121 Py_INCREF(obj);
3122 return Py_BuildValue((char *)"");
3123 }
3124 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3125 PyObject *resultobj;
3126 wxGridCellNumberRenderer *result;
3127 char *kwnames[] = {
3128 NULL
3129 };
3130
3131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3132 {
3133 PyThreadState* __tstate = wxPyBeginAllowThreads();
3134 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3135
3136 wxPyEndAllowThreads(__tstate);
3137 if (PyErr_Occurred()) SWIG_fail;
3138 }
3139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3140 return resultobj;
3141 fail:
3142 return NULL;
3143 }
3144
3145
3146 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3147 PyObject *obj;
3148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3149 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3150 Py_INCREF(obj);
3151 return Py_BuildValue((char *)"");
3152 }
3153 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj;
3155 int arg1 = (int) -1 ;
3156 int arg2 = (int) -1 ;
3157 wxGridCellFloatRenderer *result;
3158 PyObject * obj0 = 0 ;
3159 PyObject * obj1 = 0 ;
3160 char *kwnames[] = {
3161 (char *) "width",(char *) "precision", NULL
3162 };
3163
3164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3165 if (obj0) {
3166 {
3167 arg1 = (int)(SWIG_As_int(obj0));
3168 if (SWIG_arg_fail(1)) SWIG_fail;
3169 }
3170 }
3171 if (obj1) {
3172 {
3173 arg2 = (int)(SWIG_As_int(obj1));
3174 if (SWIG_arg_fail(2)) SWIG_fail;
3175 }
3176 }
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3180
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3185 return resultobj;
3186 fail:
3187 return NULL;
3188 }
3189
3190
3191 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3192 PyObject *resultobj;
3193 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3194 int result;
3195 PyObject * obj0 = 0 ;
3196 char *kwnames[] = {
3197 (char *) "self", NULL
3198 };
3199
3200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3202 if (SWIG_arg_fail(1)) SWIG_fail;
3203 {
3204 PyThreadState* __tstate = wxPyBeginAllowThreads();
3205 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3206
3207 wxPyEndAllowThreads(__tstate);
3208 if (PyErr_Occurred()) SWIG_fail;
3209 }
3210 {
3211 resultobj = SWIG_From_int((int)(result));
3212 }
3213 return resultobj;
3214 fail:
3215 return NULL;
3216 }
3217
3218
3219 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3220 PyObject *resultobj;
3221 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3222 int arg2 ;
3223 PyObject * obj0 = 0 ;
3224 PyObject * obj1 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "self",(char *) "width", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3231 if (SWIG_arg_fail(1)) SWIG_fail;
3232 {
3233 arg2 = (int)(SWIG_As_int(obj1));
3234 if (SWIG_arg_fail(2)) SWIG_fail;
3235 }
3236 {
3237 PyThreadState* __tstate = wxPyBeginAllowThreads();
3238 (arg1)->SetWidth(arg2);
3239
3240 wxPyEndAllowThreads(__tstate);
3241 if (PyErr_Occurred()) SWIG_fail;
3242 }
3243 Py_INCREF(Py_None); resultobj = Py_None;
3244 return resultobj;
3245 fail:
3246 return NULL;
3247 }
3248
3249
3250 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3251 PyObject *resultobj;
3252 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3253 int result;
3254 PyObject * obj0 = 0 ;
3255 char *kwnames[] = {
3256 (char *) "self", NULL
3257 };
3258
3259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3261 if (SWIG_arg_fail(1)) SWIG_fail;
3262 {
3263 PyThreadState* __tstate = wxPyBeginAllowThreads();
3264 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3265
3266 wxPyEndAllowThreads(__tstate);
3267 if (PyErr_Occurred()) SWIG_fail;
3268 }
3269 {
3270 resultobj = SWIG_From_int((int)(result));
3271 }
3272 return resultobj;
3273 fail:
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3281 int arg2 ;
3282 PyObject * obj0 = 0 ;
3283 PyObject * obj1 = 0 ;
3284 char *kwnames[] = {
3285 (char *) "self",(char *) "precision", NULL
3286 };
3287
3288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3290 if (SWIG_arg_fail(1)) SWIG_fail;
3291 {
3292 arg2 = (int)(SWIG_As_int(obj1));
3293 if (SWIG_arg_fail(2)) SWIG_fail;
3294 }
3295 {
3296 PyThreadState* __tstate = wxPyBeginAllowThreads();
3297 (arg1)->SetPrecision(arg2);
3298
3299 wxPyEndAllowThreads(__tstate);
3300 if (PyErr_Occurred()) SWIG_fail;
3301 }
3302 Py_INCREF(Py_None); resultobj = Py_None;
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3310 PyObject *obj;
3311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3312 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3313 Py_INCREF(obj);
3314 return Py_BuildValue((char *)"");
3315 }
3316 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3317 PyObject *resultobj;
3318 wxGridCellBoolRenderer *result;
3319 char *kwnames[] = {
3320 NULL
3321 };
3322
3323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3324 {
3325 PyThreadState* __tstate = wxPyBeginAllowThreads();
3326 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3327
3328 wxPyEndAllowThreads(__tstate);
3329 if (PyErr_Occurred()) SWIG_fail;
3330 }
3331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3339 PyObject *obj;
3340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3341 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3342 Py_INCREF(obj);
3343 return Py_BuildValue((char *)"");
3344 }
3345 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxString arg1 = (wxString) wxPyDateTimeFormatStr ;
3348 wxString arg2 = (wxString) wxPyDateTimeFormatStr ;
3349 wxGridCellDateTimeRenderer *result;
3350 PyObject * obj0 = 0 ;
3351 PyObject * obj1 = 0 ;
3352 char *kwnames[] = {
3353 (char *) "outformat",(char *) "informat", NULL
3354 };
3355
3356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3357 if (obj0) {
3358 {
3359 wxString* sptr = wxString_in_helper(obj0);
3360 if (sptr == NULL) SWIG_fail;
3361 arg1 = *sptr;
3362 delete sptr;
3363 }
3364 }
3365 if (obj1) {
3366 {
3367 wxString* sptr = wxString_in_helper(obj1);
3368 if (sptr == NULL) SWIG_fail;
3369 arg2 = *sptr;
3370 delete sptr;
3371 }
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3388 PyObject *obj;
3389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3390 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3391 Py_INCREF(obj);
3392 return Py_BuildValue((char *)"");
3393 }
3394 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxString const &arg1_defvalue = wxPyEmptyString ;
3397 wxString *arg1 = (wxString *) &arg1_defvalue ;
3398 wxGridCellEnumRenderer *result;
3399 bool temp1 = false ;
3400 PyObject * obj0 = 0 ;
3401 char *kwnames[] = {
3402 (char *) "choices", NULL
3403 };
3404
3405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3406 if (obj0) {
3407 {
3408 arg1 = wxString_in_helper(obj0);
3409 if (arg1 == NULL) SWIG_fail;
3410 temp1 = true;
3411 }
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3421 {
3422 if (temp1)
3423 delete arg1;
3424 }
3425 return resultobj;
3426 fail:
3427 {
3428 if (temp1)
3429 delete arg1;
3430 }
3431 return NULL;
3432 }
3433
3434
3435 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3436 PyObject *obj;
3437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3438 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3439 Py_INCREF(obj);
3440 return Py_BuildValue((char *)"");
3441 }
3442 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3443 PyObject *resultobj;
3444 wxGridCellAutoWrapStringRenderer *result;
3445 char *kwnames[] = {
3446 NULL
3447 };
3448
3449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3465 PyObject *obj;
3466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3467 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3468 Py_INCREF(obj);
3469 return Py_BuildValue((char *)"");
3470 }
3471 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3474 PyObject *arg2 = (PyObject *) 0 ;
3475 PyObject * obj0 = 0 ;
3476 PyObject * obj1 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self",(char *) "_self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 arg2 = obj1;
3485 {
3486 PyThreadState* __tstate = wxPyBeginAllowThreads();
3487 wxGridCellEditor__setOORInfo(arg1,arg2);
3488
3489 wxPyEndAllowThreads(__tstate);
3490 if (PyErr_Occurred()) SWIG_fail;
3491 }
3492 Py_INCREF(Py_None); resultobj = Py_None;
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3502 bool result;
3503 PyObject * obj0 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 PyThreadState* __tstate = wxPyBeginAllowThreads();
3513 result = (bool)(arg1)->IsCreated();
3514
3515 wxPyEndAllowThreads(__tstate);
3516 if (PyErr_Occurred()) SWIG_fail;
3517 }
3518 {
3519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3520 }
3521 return resultobj;
3522 fail:
3523 return NULL;
3524 }
3525
3526
3527 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3528 PyObject *resultobj;
3529 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3530 wxControl *result;
3531 PyObject * obj0 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 {
3540 PyThreadState* __tstate = wxPyBeginAllowThreads();
3541 result = (wxControl *)(arg1)->GetControl();
3542
3543 wxPyEndAllowThreads(__tstate);
3544 if (PyErr_Occurred()) SWIG_fail;
3545 }
3546 {
3547 resultobj = wxPyMake_wxObject(result, 0);
3548 }
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3558 wxControl *arg2 = (wxControl *) 0 ;
3559 PyObject * obj0 = 0 ;
3560 PyObject * obj1 = 0 ;
3561 char *kwnames[] = {
3562 (char *) "self",(char *) "control", NULL
3563 };
3564
3565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3567 if (SWIG_arg_fail(1)) SWIG_fail;
3568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(2)) SWIG_fail;
3570 {
3571 PyThreadState* __tstate = wxPyBeginAllowThreads();
3572 (arg1)->SetControl(arg2);
3573
3574 wxPyEndAllowThreads(__tstate);
3575 if (PyErr_Occurred()) SWIG_fail;
3576 }
3577 Py_INCREF(Py_None); resultobj = Py_None;
3578 return resultobj;
3579 fail:
3580 return NULL;
3581 }
3582
3583
3584 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3585 PyObject *resultobj;
3586 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3587 wxGridCellAttr *result;
3588 PyObject * obj0 = 0 ;
3589 char *kwnames[] = {
3590 (char *) "self", NULL
3591 };
3592
3593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3595 if (SWIG_arg_fail(1)) SWIG_fail;
3596 {
3597 PyThreadState* __tstate = wxPyBeginAllowThreads();
3598 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3599
3600 wxPyEndAllowThreads(__tstate);
3601 if (PyErr_Occurred()) SWIG_fail;
3602 }
3603 {
3604 resultobj = wxPyMake_wxGridCellAttr(result, 0);
3605 }
3606 return resultobj;
3607 fail:
3608 return NULL;
3609 }
3610
3611
3612 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3613 PyObject *resultobj;
3614 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3615 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3616 PyObject * obj0 = 0 ;
3617 PyObject * obj1 = 0 ;
3618 char *kwnames[] = {
3619 (char *) "self",(char *) "attr", NULL
3620 };
3621
3622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3624 if (SWIG_arg_fail(1)) SWIG_fail;
3625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3626 if (SWIG_arg_fail(2)) SWIG_fail;
3627 {
3628 PyThreadState* __tstate = wxPyBeginAllowThreads();
3629 (arg1)->SetCellAttr(arg2);
3630
3631 wxPyEndAllowThreads(__tstate);
3632 if (PyErr_Occurred()) SWIG_fail;
3633 }
3634 Py_INCREF(Py_None); resultobj = Py_None;
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3642 PyObject *resultobj;
3643 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3644 wxString *arg2 = 0 ;
3645 bool temp2 = false ;
3646 PyObject * obj0 = 0 ;
3647 PyObject * obj1 = 0 ;
3648 char *kwnames[] = {
3649 (char *) "self",(char *) "params", NULL
3650 };
3651
3652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3654 if (SWIG_arg_fail(1)) SWIG_fail;
3655 {
3656 arg2 = wxString_in_helper(obj1);
3657 if (arg2 == NULL) SWIG_fail;
3658 temp2 = true;
3659 }
3660 {
3661 PyThreadState* __tstate = wxPyBeginAllowThreads();
3662 (arg1)->SetParameters((wxString const &)*arg2);
3663
3664 wxPyEndAllowThreads(__tstate);
3665 if (PyErr_Occurred()) SWIG_fail;
3666 }
3667 Py_INCREF(Py_None); resultobj = Py_None;
3668 {
3669 if (temp2)
3670 delete arg2;
3671 }
3672 return resultobj;
3673 fail:
3674 {
3675 if (temp2)
3676 delete arg2;
3677 }
3678 return NULL;
3679 }
3680
3681
3682 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj;
3684 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3685 PyObject * obj0 = 0 ;
3686 char *kwnames[] = {
3687 (char *) "self", NULL
3688 };
3689
3690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3692 if (SWIG_arg_fail(1)) SWIG_fail;
3693 {
3694 PyThreadState* __tstate = wxPyBeginAllowThreads();
3695 (arg1)->IncRef();
3696
3697 wxPyEndAllowThreads(__tstate);
3698 if (PyErr_Occurred()) SWIG_fail;
3699 }
3700 Py_INCREF(Py_None); resultobj = Py_None;
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3710 PyObject * obj0 = 0 ;
3711 char *kwnames[] = {
3712 (char *) "self", NULL
3713 };
3714
3715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3717 if (SWIG_arg_fail(1)) SWIG_fail;
3718 {
3719 PyThreadState* __tstate = wxPyBeginAllowThreads();
3720 (arg1)->DecRef();
3721
3722 wxPyEndAllowThreads(__tstate);
3723 if (PyErr_Occurred()) SWIG_fail;
3724 }
3725 Py_INCREF(Py_None); resultobj = Py_None;
3726 return resultobj;
3727 fail:
3728 return NULL;
3729 }
3730
3731
3732 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3733 PyObject *resultobj;
3734 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3735 wxWindow *arg2 = (wxWindow *) 0 ;
3736 int arg3 ;
3737 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3738 PyObject * obj0 = 0 ;
3739 PyObject * obj1 = 0 ;
3740 PyObject * obj2 = 0 ;
3741 PyObject * obj3 = 0 ;
3742 char *kwnames[] = {
3743 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3744 };
3745
3746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3748 if (SWIG_arg_fail(1)) SWIG_fail;
3749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3750 if (SWIG_arg_fail(2)) SWIG_fail;
3751 {
3752 arg3 = (int)(SWIG_As_int(obj2));
3753 if (SWIG_arg_fail(3)) SWIG_fail;
3754 }
3755 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3756 if (SWIG_arg_fail(4)) SWIG_fail;
3757 {
3758 PyThreadState* __tstate = wxPyBeginAllowThreads();
3759 (arg1)->Create(arg2,arg3,arg4);
3760
3761 wxPyEndAllowThreads(__tstate);
3762 if (PyErr_Occurred()) SWIG_fail;
3763 }
3764 Py_INCREF(Py_None); resultobj = Py_None;
3765 return resultobj;
3766 fail:
3767 return NULL;
3768 }
3769
3770
3771 static PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3772 PyObject *resultobj;
3773 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3774 int arg2 ;
3775 int arg3 ;
3776 wxGrid *arg4 = (wxGrid *) 0 ;
3777 PyObject * obj0 = 0 ;
3778 PyObject * obj1 = 0 ;
3779 PyObject * obj2 = 0 ;
3780 PyObject * obj3 = 0 ;
3781 char *kwnames[] = {
3782 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3783 };
3784
3785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3787 if (SWIG_arg_fail(1)) SWIG_fail;
3788 {
3789 arg2 = (int)(SWIG_As_int(obj1));
3790 if (SWIG_arg_fail(2)) SWIG_fail;
3791 }
3792 {
3793 arg3 = (int)(SWIG_As_int(obj2));
3794 if (SWIG_arg_fail(3)) SWIG_fail;
3795 }
3796 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3797 if (SWIG_arg_fail(4)) SWIG_fail;
3798 {
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 (arg1)->BeginEdit(arg2,arg3,arg4);
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 Py_INCREF(Py_None); resultobj = Py_None;
3806 return resultobj;
3807 fail:
3808 return NULL;
3809 }
3810
3811
3812 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3813 PyObject *resultobj;
3814 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3815 int arg2 ;
3816 int arg3 ;
3817 wxGrid *arg4 = (wxGrid *) 0 ;
3818 bool result;
3819 PyObject * obj0 = 0 ;
3820 PyObject * obj1 = 0 ;
3821 PyObject * obj2 = 0 ;
3822 PyObject * obj3 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 arg2 = (int)(SWIG_As_int(obj1));
3832 if (SWIG_arg_fail(2)) SWIG_fail;
3833 }
3834 {
3835 arg3 = (int)(SWIG_As_int(obj2));
3836 if (SWIG_arg_fail(3)) SWIG_fail;
3837 }
3838 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3839 if (SWIG_arg_fail(4)) SWIG_fail;
3840 {
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 {
3848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3849 }
3850 return resultobj;
3851 fail:
3852 return NULL;
3853 }
3854
3855
3856 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
3857 PyObject *resultobj;
3858 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3859 PyObject * obj0 = 0 ;
3860 char *kwnames[] = {
3861 (char *) "self", NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
3865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3866 if (SWIG_arg_fail(1)) SWIG_fail;
3867 {
3868 PyThreadState* __tstate = wxPyBeginAllowThreads();
3869 (arg1)->Reset();
3870
3871 wxPyEndAllowThreads(__tstate);
3872 if (PyErr_Occurred()) SWIG_fail;
3873 }
3874 Py_INCREF(Py_None); resultobj = Py_None;
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3884 wxGridCellEditor *result;
3885 PyObject * obj0 = 0 ;
3886 char *kwnames[] = {
3887 (char *) "self", NULL
3888 };
3889
3890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
3891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3892 if (SWIG_arg_fail(1)) SWIG_fail;
3893 {
3894 PyThreadState* __tstate = wxPyBeginAllowThreads();
3895 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
3896
3897 wxPyEndAllowThreads(__tstate);
3898 if (PyErr_Occurred()) SWIG_fail;
3899 }
3900 {
3901 resultobj = wxPyMake_wxGridCellEditor(result, 0);
3902 }
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3912 wxRect *arg2 = 0 ;
3913 wxRect temp2 ;
3914 PyObject * obj0 = 0 ;
3915 PyObject * obj1 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "self",(char *) "rect", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
3921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3922 if (SWIG_arg_fail(1)) SWIG_fail;
3923 {
3924 arg2 = &temp2;
3925 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3926 }
3927 {
3928 PyThreadState* __tstate = wxPyBeginAllowThreads();
3929 (arg1)->SetSize((wxRect const &)*arg2);
3930
3931 wxPyEndAllowThreads(__tstate);
3932 if (PyErr_Occurred()) SWIG_fail;
3933 }
3934 Py_INCREF(Py_None); resultobj = Py_None;
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3944 bool arg2 ;
3945 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
3946 PyObject * obj0 = 0 ;
3947 PyObject * obj1 = 0 ;
3948 PyObject * obj2 = 0 ;
3949 char *kwnames[] = {
3950 (char *) "self",(char *) "show",(char *) "attr", NULL
3951 };
3952
3953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
3954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3955 if (SWIG_arg_fail(1)) SWIG_fail;
3956 {
3957 arg2 = (bool)(SWIG_As_bool(obj1));
3958 if (SWIG_arg_fail(2)) SWIG_fail;
3959 }
3960 if (obj2) {
3961 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3962 if (SWIG_arg_fail(3)) SWIG_fail;
3963 }
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 (arg1)->Show(arg2,arg3);
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3981 wxRect *arg2 = 0 ;
3982 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
3983 wxRect temp2 ;
3984 PyObject * obj0 = 0 ;
3985 PyObject * obj1 = 0 ;
3986 PyObject * obj2 = 0 ;
3987 char *kwnames[] = {
3988 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
3989 };
3990
3991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
3992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3993 if (SWIG_arg_fail(1)) SWIG_fail;
3994 {
3995 arg2 = &temp2;
3996 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3997 }
3998 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3999 if (SWIG_arg_fail(3)) SWIG_fail;
4000 {
4001 PyThreadState* __tstate = wxPyBeginAllowThreads();
4002 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
4003
4004 wxPyEndAllowThreads(__tstate);
4005 if (PyErr_Occurred()) SWIG_fail;
4006 }
4007 Py_INCREF(Py_None); resultobj = Py_None;
4008 return resultobj;
4009 fail:
4010 return NULL;
4011 }
4012
4013
4014 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4015 PyObject *resultobj;
4016 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4017 wxKeyEvent *arg2 = 0 ;
4018 bool result;
4019 PyObject * obj0 = 0 ;
4020 PyObject * obj1 = 0 ;
4021 char *kwnames[] = {
4022 (char *) "self",(char *) "event", NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4027 if (SWIG_arg_fail(1)) SWIG_fail;
4028 {
4029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4030 if (SWIG_arg_fail(2)) SWIG_fail;
4031 if (arg2 == NULL) {
4032 SWIG_null_ref("wxKeyEvent");
4033 }
4034 if (SWIG_arg_fail(2)) SWIG_fail;
4035 }
4036 {
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 {
4044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4045 }
4046 return resultobj;
4047 fail:
4048 return NULL;
4049 }
4050
4051
4052 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4053 PyObject *resultobj;
4054 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4055 wxKeyEvent *arg2 = 0 ;
4056 PyObject * obj0 = 0 ;
4057 PyObject * obj1 = 0 ;
4058 char *kwnames[] = {
4059 (char *) "self",(char *) "event", NULL
4060 };
4061
4062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4064 if (SWIG_arg_fail(1)) SWIG_fail;
4065 {
4066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4067 if (SWIG_arg_fail(2)) SWIG_fail;
4068 if (arg2 == NULL) {
4069 SWIG_null_ref("wxKeyEvent");
4070 }
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 {
4074 PyThreadState* __tstate = wxPyBeginAllowThreads();
4075 (arg1)->StartingKey(*arg2);
4076
4077 wxPyEndAllowThreads(__tstate);
4078 if (PyErr_Occurred()) SWIG_fail;
4079 }
4080 Py_INCREF(Py_None); resultobj = Py_None;
4081 return resultobj;
4082 fail:
4083 return NULL;
4084 }
4085
4086
4087 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj;
4089 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4090 PyObject * obj0 = 0 ;
4091 char *kwnames[] = {
4092 (char *) "self", NULL
4093 };
4094
4095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4097 if (SWIG_arg_fail(1)) SWIG_fail;
4098 {
4099 PyThreadState* __tstate = wxPyBeginAllowThreads();
4100 (arg1)->StartingClick();
4101
4102 wxPyEndAllowThreads(__tstate);
4103 if (PyErr_Occurred()) SWIG_fail;
4104 }
4105 Py_INCREF(Py_None); resultobj = Py_None;
4106 return resultobj;
4107 fail:
4108 return NULL;
4109 }
4110
4111
4112 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4113 PyObject *resultobj;
4114 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4115 wxKeyEvent *arg2 = 0 ;
4116 PyObject * obj0 = 0 ;
4117 PyObject * obj1 = 0 ;
4118 char *kwnames[] = {
4119 (char *) "self",(char *) "event", NULL
4120 };
4121
4122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4124 if (SWIG_arg_fail(1)) SWIG_fail;
4125 {
4126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(2)) SWIG_fail;
4128 if (arg2 == NULL) {
4129 SWIG_null_ref("wxKeyEvent");
4130 }
4131 if (SWIG_arg_fail(2)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 (arg1)->HandleReturn(*arg2);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 Py_INCREF(Py_None); resultobj = Py_None;
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4150 PyObject * obj0 = 0 ;
4151 char *kwnames[] = {
4152 (char *) "self", NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 (arg1)->Destroy();
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 Py_INCREF(Py_None); resultobj = Py_None;
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4173 PyObject *obj;
4174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4175 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4176 Py_INCREF(obj);
4177 return Py_BuildValue((char *)"");
4178 }
4179 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4180 PyObject *resultobj;
4181 wxPyGridCellEditor *result;
4182 char *kwnames[] = {
4183 NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4187 {
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4204 PyObject *arg2 = (PyObject *) 0 ;
4205 PyObject *arg3 = (PyObject *) 0 ;
4206 PyObject * obj0 = 0 ;
4207 PyObject * obj1 = 0 ;
4208 PyObject * obj2 = 0 ;
4209 char *kwnames[] = {
4210 (char *) "self",(char *) "self",(char *) "_class", NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4215 if (SWIG_arg_fail(1)) SWIG_fail;
4216 arg2 = obj1;
4217 arg3 = obj2;
4218 {
4219 PyThreadState* __tstate = wxPyBeginAllowThreads();
4220 (arg1)->_setCallbackInfo(arg2,arg3);
4221
4222 wxPyEndAllowThreads(__tstate);
4223 if (PyErr_Occurred()) SWIG_fail;
4224 }
4225 Py_INCREF(Py_None); resultobj = Py_None;
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 static PyObject *_wrap_PyGridCellEditor_base_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4233 PyObject *resultobj;
4234 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4235 wxRect *arg2 = 0 ;
4236 wxRect temp2 ;
4237 PyObject * obj0 = 0 ;
4238 PyObject * obj1 = 0 ;
4239 char *kwnames[] = {
4240 (char *) "self",(char *) "rect", NULL
4241 };
4242
4243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetSize",kwnames,&obj0,&obj1)) goto fail;
4244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4245 if (SWIG_arg_fail(1)) SWIG_fail;
4246 {
4247 arg2 = &temp2;
4248 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4249 }
4250 {
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 (arg1)->base_SetSize((wxRect const &)*arg2);
4253
4254 wxPyEndAllowThreads(__tstate);
4255 if (PyErr_Occurred()) SWIG_fail;
4256 }
4257 Py_INCREF(Py_None); resultobj = Py_None;
4258 return resultobj;
4259 fail:
4260 return NULL;
4261 }
4262
4263
4264 static PyObject *_wrap_PyGridCellEditor_base_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4265 PyObject *resultobj;
4266 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4267 bool arg2 ;
4268 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4269 PyObject * obj0 = 0 ;
4270 PyObject * obj1 = 0 ;
4271 PyObject * obj2 = 0 ;
4272 char *kwnames[] = {
4273 (char *) "self",(char *) "show",(char *) "attr", NULL
4274 };
4275
4276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_base_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4278 if (SWIG_arg_fail(1)) SWIG_fail;
4279 {
4280 arg2 = (bool)(SWIG_As_bool(obj1));
4281 if (SWIG_arg_fail(2)) SWIG_fail;
4282 }
4283 if (obj2) {
4284 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4285 if (SWIG_arg_fail(3)) SWIG_fail;
4286 }
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 (arg1)->base_Show(arg2,arg3);
4290
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 Py_INCREF(Py_None); resultobj = Py_None;
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_PyGridCellEditor_base_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj;
4303 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4304 wxRect *arg2 = 0 ;
4305 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4306 wxRect temp2 ;
4307 PyObject * obj0 = 0 ;
4308 PyObject * obj1 = 0 ;
4309 PyObject * obj2 = 0 ;
4310 char *kwnames[] = {
4311 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4312 };
4313
4314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_base_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4316 if (SWIG_arg_fail(1)) SWIG_fail;
4317 {
4318 arg2 = &temp2;
4319 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4320 }
4321 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4322 if (SWIG_arg_fail(3)) SWIG_fail;
4323 {
4324 PyThreadState* __tstate = wxPyBeginAllowThreads();
4325 (arg1)->base_PaintBackground((wxRect const &)*arg2,arg3);
4326
4327 wxPyEndAllowThreads(__tstate);
4328 if (PyErr_Occurred()) SWIG_fail;
4329 }
4330 Py_INCREF(Py_None); resultobj = Py_None;
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_PyGridCellEditor_base_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4340 wxKeyEvent *arg2 = 0 ;
4341 bool result;
4342 PyObject * obj0 = 0 ;
4343 PyObject * obj1 = 0 ;
4344 char *kwnames[] = {
4345 (char *) "self",(char *) "event", NULL
4346 };
4347
4348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4350 if (SWIG_arg_fail(1)) SWIG_fail;
4351 {
4352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4353 if (SWIG_arg_fail(2)) SWIG_fail;
4354 if (arg2 == NULL) {
4355 SWIG_null_ref("wxKeyEvent");
4356 }
4357 if (SWIG_arg_fail(2)) SWIG_fail;
4358 }
4359 {
4360 PyThreadState* __tstate = wxPyBeginAllowThreads();
4361 result = (bool)(arg1)->base_IsAcceptedKey(*arg2);
4362
4363 wxPyEndAllowThreads(__tstate);
4364 if (PyErr_Occurred()) SWIG_fail;
4365 }
4366 {
4367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4368 }
4369 return resultobj;
4370 fail:
4371 return NULL;
4372 }
4373
4374
4375 static PyObject *_wrap_PyGridCellEditor_base_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4376 PyObject *resultobj;
4377 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4378 wxKeyEvent *arg2 = 0 ;
4379 PyObject * obj0 = 0 ;
4380 PyObject * obj1 = 0 ;
4381 char *kwnames[] = {
4382 (char *) "self",(char *) "event", NULL
4383 };
4384
4385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4387 if (SWIG_arg_fail(1)) SWIG_fail;
4388 {
4389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4390 if (SWIG_arg_fail(2)) SWIG_fail;
4391 if (arg2 == NULL) {
4392 SWIG_null_ref("wxKeyEvent");
4393 }
4394 if (SWIG_arg_fail(2)) SWIG_fail;
4395 }
4396 {
4397 PyThreadState* __tstate = wxPyBeginAllowThreads();
4398 (arg1)->base_StartingKey(*arg2);
4399
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 Py_INCREF(Py_None); resultobj = Py_None;
4404 return resultobj;
4405 fail:
4406 return NULL;
4407 }
4408
4409
4410 static PyObject *_wrap_PyGridCellEditor_base_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj;
4412 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4413 PyObject * obj0 = 0 ;
4414 char *kwnames[] = {
4415 (char *) "self", NULL
4416 };
4417
4418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_StartingClick",kwnames,&obj0)) goto fail;
4419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4420 if (SWIG_arg_fail(1)) SWIG_fail;
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 (arg1)->base_StartingClick();
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 Py_INCREF(Py_None); resultobj = Py_None;
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_PyGridCellEditor_base_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj;
4437 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4438 wxKeyEvent *arg2 = 0 ;
4439 PyObject * obj0 = 0 ;
4440 PyObject * obj1 = 0 ;
4441 char *kwnames[] = {
4442 (char *) "self",(char *) "event", NULL
4443 };
4444
4445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4447 if (SWIG_arg_fail(1)) SWIG_fail;
4448 {
4449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4450 if (SWIG_arg_fail(2)) SWIG_fail;
4451 if (arg2 == NULL) {
4452 SWIG_null_ref("wxKeyEvent");
4453 }
4454 if (SWIG_arg_fail(2)) SWIG_fail;
4455 }
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 (arg1)->base_HandleReturn(*arg2);
4459
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 Py_INCREF(Py_None); resultobj = Py_None;
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 static PyObject *_wrap_PyGridCellEditor_base_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj;
4472 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4473 PyObject * obj0 = 0 ;
4474 char *kwnames[] = {
4475 (char *) "self", NULL
4476 };
4477
4478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_Destroy",kwnames,&obj0)) goto fail;
4479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4480 if (SWIG_arg_fail(1)) SWIG_fail;
4481 {
4482 PyThreadState* __tstate = wxPyBeginAllowThreads();
4483 (arg1)->base_Destroy();
4484
4485 wxPyEndAllowThreads(__tstate);
4486 if (PyErr_Occurred()) SWIG_fail;
4487 }
4488 Py_INCREF(Py_None); resultobj = Py_None;
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 static PyObject *_wrap_PyGridCellEditor_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj;
4497 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4498 wxString *arg2 = 0 ;
4499 bool temp2 = false ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 char *kwnames[] = {
4503 (char *) "self",(char *) "params", NULL
4504 };
4505
4506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
4507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(1)) SWIG_fail;
4509 {
4510 arg2 = wxString_in_helper(obj1);
4511 if (arg2 == NULL) SWIG_fail;
4512 temp2 = true;
4513 }
4514 {
4515 PyThreadState* __tstate = wxPyBeginAllowThreads();
4516 (arg1)->base_SetParameters((wxString const &)*arg2);
4517
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 Py_INCREF(Py_None); resultobj = Py_None;
4522 {
4523 if (temp2)
4524 delete arg2;
4525 }
4526 return resultobj;
4527 fail:
4528 {
4529 if (temp2)
4530 delete arg2;
4531 }
4532 return NULL;
4533 }
4534
4535
4536 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4537 PyObject *obj;
4538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4539 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4540 Py_INCREF(obj);
4541 return Py_BuildValue((char *)"");
4542 }
4543 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4544 PyObject *resultobj;
4545 wxGridCellTextEditor *result;
4546 char *kwnames[] = {
4547 NULL
4548 };
4549
4550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4551 {
4552 PyThreadState* __tstate = wxPyBeginAllowThreads();
4553 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4554
4555 wxPyEndAllowThreads(__tstate);
4556 if (PyErr_Occurred()) SWIG_fail;
4557 }
4558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4566 PyObject *resultobj;
4567 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4568 wxString result;
4569 PyObject * obj0 = 0 ;
4570 char *kwnames[] = {
4571 (char *) "self", NULL
4572 };
4573
4574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4576 if (SWIG_arg_fail(1)) SWIG_fail;
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (arg1)->GetValue();
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 #if wxUSE_UNICODE
4586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4587 #else
4588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4589 #endif
4590 }
4591 return resultobj;
4592 fail:
4593 return NULL;
4594 }
4595
4596
4597 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4598 PyObject *obj;
4599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4600 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4601 Py_INCREF(obj);
4602 return Py_BuildValue((char *)"");
4603 }
4604 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4605 PyObject *resultobj;
4606 int arg1 = (int) -1 ;
4607 int arg2 = (int) -1 ;
4608 wxGridCellNumberEditor *result;
4609 PyObject * obj0 = 0 ;
4610 PyObject * obj1 = 0 ;
4611 char *kwnames[] = {
4612 (char *) "min",(char *) "max", NULL
4613 };
4614
4615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4616 if (obj0) {
4617 {
4618 arg1 = (int)(SWIG_As_int(obj0));
4619 if (SWIG_arg_fail(1)) SWIG_fail;
4620 }
4621 }
4622 if (obj1) {
4623 {
4624 arg2 = (int)(SWIG_As_int(obj1));
4625 if (SWIG_arg_fail(2)) SWIG_fail;
4626 }
4627 }
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj;
4644 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4645 wxString result;
4646 PyObject * obj0 = 0 ;
4647 char *kwnames[] = {
4648 (char *) "self", NULL
4649 };
4650
4651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4653 if (SWIG_arg_fail(1)) SWIG_fail;
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = (arg1)->GetValue();
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 #if wxUSE_UNICODE
4663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4664 #else
4665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4666 #endif
4667 }
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4675 PyObject *obj;
4676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4677 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4678 Py_INCREF(obj);
4679 return Py_BuildValue((char *)"");
4680 }
4681 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4682 PyObject *resultobj;
4683 int arg1 = (int) -1 ;
4684 int arg2 = (int) -1 ;
4685 wxGridCellFloatEditor *result;
4686 PyObject * obj0 = 0 ;
4687 PyObject * obj1 = 0 ;
4688 char *kwnames[] = {
4689 (char *) "width",(char *) "precision", NULL
4690 };
4691
4692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4693 if (obj0) {
4694 {
4695 arg1 = (int)(SWIG_As_int(obj0));
4696 if (SWIG_arg_fail(1)) SWIG_fail;
4697 }
4698 }
4699 if (obj1) {
4700 {
4701 arg2 = (int)(SWIG_As_int(obj1));
4702 if (SWIG_arg_fail(2)) SWIG_fail;
4703 }
4704 }
4705 {
4706 PyThreadState* __tstate = wxPyBeginAllowThreads();
4707 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4708
4709 wxPyEndAllowThreads(__tstate);
4710 if (PyErr_Occurred()) SWIG_fail;
4711 }
4712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4720 PyObject *resultobj;
4721 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4722 wxString result;
4723 PyObject * obj0 = 0 ;
4724 char *kwnames[] = {
4725 (char *) "self", NULL
4726 };
4727
4728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4730 if (SWIG_arg_fail(1)) SWIG_fail;
4731 {
4732 PyThreadState* __tstate = wxPyBeginAllowThreads();
4733 result = (arg1)->GetValue();
4734
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 #if wxUSE_UNICODE
4740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4741 #else
4742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4743 #endif
4744 }
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4752 PyObject *obj;
4753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4754 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4755 Py_INCREF(obj);
4756 return Py_BuildValue((char *)"");
4757 }
4758 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 wxGridCellBoolEditor *result;
4761 char *kwnames[] = {
4762 NULL
4763 };
4764
4765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4769
4770 wxPyEndAllowThreads(__tstate);
4771 if (PyErr_Occurred()) SWIG_fail;
4772 }
4773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj;
4782 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4783 wxString result;
4784 PyObject * obj0 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "self", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4791 if (SWIG_arg_fail(1)) SWIG_fail;
4792 {
4793 PyThreadState* __tstate = wxPyBeginAllowThreads();
4794 result = (arg1)->GetValue();
4795
4796 wxPyEndAllowThreads(__tstate);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 {
4800 #if wxUSE_UNICODE
4801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4802 #else
4803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4804 #endif
4805 }
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
4813 PyObject *obj;
4814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4815 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
4816 Py_INCREF(obj);
4817 return Py_BuildValue((char *)"");
4818 }
4819 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj;
4821 int arg1 = (int) 0 ;
4822 wxString *arg2 = (wxString *) NULL ;
4823 bool arg3 = (bool) false ;
4824 wxGridCellChoiceEditor *result;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "choices",(char *) "allowOthers", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
4832 if (obj0) {
4833 {
4834 arg1 = PyList_Size(obj0);
4835 arg2 = wxString_LIST_helper(obj0);
4836 if (arg2 == NULL) SWIG_fail;
4837 }
4838 }
4839 if (obj1) {
4840 {
4841 arg3 = (bool)(SWIG_As_bool(obj1));
4842 if (SWIG_arg_fail(3)) SWIG_fail;
4843 }
4844 }
4845 {
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
4848
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
4853 {
4854 if (arg2) delete [] arg2;
4855 }
4856 return resultobj;
4857 fail:
4858 {
4859 if (arg2) delete [] arg2;
4860 }
4861 return NULL;
4862 }
4863
4864
4865 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4866 PyObject *resultobj;
4867 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
4868 wxString result;
4869 PyObject * obj0 = 0 ;
4870 char *kwnames[] = {
4871 (char *) "self", NULL
4872 };
4873
4874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
4875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
4876 if (SWIG_arg_fail(1)) SWIG_fail;
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = (arg1)->GetValue();
4880
4881 wxPyEndAllowThreads(__tstate);
4882 if (PyErr_Occurred()) SWIG_fail;
4883 }
4884 {
4885 #if wxUSE_UNICODE
4886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4887 #else
4888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4889 #endif
4890 }
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
4898 PyObject *obj;
4899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4900 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
4901 Py_INCREF(obj);
4902 return Py_BuildValue((char *)"");
4903 }
4904 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4905 PyObject *resultobj;
4906 wxString const &arg1_defvalue = wxPyEmptyString ;
4907 wxString *arg1 = (wxString *) &arg1_defvalue ;
4908 wxGridCellEnumEditor *result;
4909 bool temp1 = false ;
4910 PyObject * obj0 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "choices", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
4916 if (obj0) {
4917 {
4918 arg1 = wxString_in_helper(obj0);
4919 if (arg1 == NULL) SWIG_fail;
4920 temp1 = true;
4921 }
4922 }
4923 {
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
4926
4927 wxPyEndAllowThreads(__tstate);
4928 if (PyErr_Occurred()) SWIG_fail;
4929 }
4930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
4931 {
4932 if (temp1)
4933 delete arg1;
4934 }
4935 return resultobj;
4936 fail:
4937 {
4938 if (temp1)
4939 delete arg1;
4940 }
4941 return NULL;
4942 }
4943
4944
4945 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj;
4947 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
4948 wxString result;
4949 PyObject * obj0 = 0 ;
4950 char *kwnames[] = {
4951 (char *) "self", NULL
4952 };
4953
4954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
4955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
4956 if (SWIG_arg_fail(1)) SWIG_fail;
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 result = (arg1)->GetValue();
4960
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 {
4965 #if wxUSE_UNICODE
4966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4967 #else
4968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4969 #endif
4970 }
4971 return resultobj;
4972 fail:
4973 return NULL;
4974 }
4975
4976
4977 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
4978 PyObject *obj;
4979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4980 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
4981 Py_INCREF(obj);
4982 return Py_BuildValue((char *)"");
4983 }
4984 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4985 PyObject *resultobj;
4986 wxGridCellAutoWrapStringEditor *result;
4987 char *kwnames[] = {
4988 NULL
4989 };
4990
4991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
5000 return resultobj;
5001 fail:
5002 return NULL;
5003 }
5004
5005
5006 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5007 PyObject *resultobj;
5008 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
5009 wxString result;
5010 PyObject * obj0 = 0 ;
5011 char *kwnames[] = {
5012 (char *) "self", NULL
5013 };
5014
5015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
5016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
5017 if (SWIG_arg_fail(1)) SWIG_fail;
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (arg1)->GetValue();
5021
5022 wxPyEndAllowThreads(__tstate);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 {
5026 #if wxUSE_UNICODE
5027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5028 #else
5029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5030 #endif
5031 }
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5039 PyObject *obj;
5040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5041 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5042 Py_INCREF(obj);
5043 return Py_BuildValue((char *)"");
5044 }
5045 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj;
5047 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5048 PyObject *arg2 = (PyObject *) 0 ;
5049 PyObject * obj0 = 0 ;
5050 PyObject * obj1 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "self",(char *) "_self", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5057 if (SWIG_arg_fail(1)) SWIG_fail;
5058 arg2 = obj1;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 wxGridCellAttr__setOORInfo(arg1,arg2);
5062
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 Py_INCREF(Py_None); resultobj = Py_None;
5067 return resultobj;
5068 fail:
5069 return NULL;
5070 }
5071
5072
5073 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5074 PyObject *resultobj;
5075 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5076 wxGridCellAttr *result;
5077 PyObject * obj0 = 0 ;
5078 char *kwnames[] = {
5079 (char *) "attrDefault", NULL
5080 };
5081
5082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5083 if (obj0) {
5084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5085 if (SWIG_arg_fail(1)) SWIG_fail;
5086 }
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5090
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 {
5095 resultobj = wxPyMake_wxGridCellAttr(result, 1);
5096 }
5097 return resultobj;
5098 fail:
5099 return NULL;
5100 }
5101
5102
5103 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5104 PyObject *resultobj;
5105 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5106 wxGridCellAttr *result;
5107 PyObject * obj0 = 0 ;
5108 char *kwnames[] = {
5109 (char *) "self", NULL
5110 };
5111
5112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5114 if (SWIG_arg_fail(1)) SWIG_fail;
5115 {
5116 PyThreadState* __tstate = wxPyBeginAllowThreads();
5117 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5118
5119 wxPyEndAllowThreads(__tstate);
5120 if (PyErr_Occurred()) SWIG_fail;
5121 }
5122 {
5123 resultobj = wxPyMake_wxGridCellAttr(result, 0);
5124 }
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5134 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5135 PyObject * obj0 = 0 ;
5136 PyObject * obj1 = 0 ;
5137 char *kwnames[] = {
5138 (char *) "self",(char *) "mergefrom", NULL
5139 };
5140
5141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5143 if (SWIG_arg_fail(1)) SWIG_fail;
5144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5145 if (SWIG_arg_fail(2)) SWIG_fail;
5146 {
5147 PyThreadState* __tstate = wxPyBeginAllowThreads();
5148 (arg1)->MergeWith(arg2);
5149
5150 wxPyEndAllowThreads(__tstate);
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 Py_INCREF(Py_None); resultobj = Py_None;
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5161 PyObject *resultobj;
5162 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5163 PyObject * obj0 = 0 ;
5164 char *kwnames[] = {
5165 (char *) "self", NULL
5166 };
5167
5168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(1)) SWIG_fail;
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 (arg1)->IncRef();
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 Py_INCREF(Py_None); resultobj = Py_None;
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj;
5187 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5188 PyObject * obj0 = 0 ;
5189 char *kwnames[] = {
5190 (char *) "self", NULL
5191 };
5192
5193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5195 if (SWIG_arg_fail(1)) SWIG_fail;
5196 {
5197 PyThreadState* __tstate = wxPyBeginAllowThreads();
5198 (arg1)->DecRef();
5199
5200 wxPyEndAllowThreads(__tstate);
5201 if (PyErr_Occurred()) SWIG_fail;
5202 }
5203 Py_INCREF(Py_None); resultobj = Py_None;
5204 return resultobj;
5205 fail:
5206 return NULL;
5207 }
5208
5209
5210 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5211 PyObject *resultobj;
5212 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5213 wxColour *arg2 = 0 ;
5214 wxColour temp2 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char *kwnames[] = {
5218 (char *) "self",(char *) "colText", NULL
5219 };
5220
5221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5223 if (SWIG_arg_fail(1)) SWIG_fail;
5224 {
5225 arg2 = &temp2;
5226 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5227 }
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 (arg1)->SetTextColour((wxColour const &)*arg2);
5231
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 Py_INCREF(Py_None); resultobj = Py_None;
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj;
5244 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5245 wxColour *arg2 = 0 ;
5246 wxColour temp2 ;
5247 PyObject * obj0 = 0 ;
5248 PyObject * obj1 = 0 ;
5249 char *kwnames[] = {
5250 (char *) "self",(char *) "colBack", NULL
5251 };
5252
5253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5255 if (SWIG_arg_fail(1)) SWIG_fail;
5256 {
5257 arg2 = &temp2;
5258 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5259 }
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5263
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 Py_INCREF(Py_None); resultobj = Py_None;
5268 return resultobj;
5269 fail:
5270 return NULL;
5271 }
5272
5273
5274 static PyObject *_wrap_GridCellAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5275 PyObject *resultobj;
5276 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5277 wxFont *arg2 = 0 ;
5278 PyObject * obj0 = 0 ;
5279 PyObject * obj1 = 0 ;
5280 char *kwnames[] = {
5281 (char *) "self",(char *) "font", NULL
5282 };
5283
5284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5286 if (SWIG_arg_fail(1)) SWIG_fail;
5287 {
5288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5289 if (SWIG_arg_fail(2)) SWIG_fail;
5290 if (arg2 == NULL) {
5291 SWIG_null_ref("wxFont");
5292 }
5293 if (SWIG_arg_fail(2)) SWIG_fail;
5294 }
5295 {
5296 PyThreadState* __tstate = wxPyBeginAllowThreads();
5297 (arg1)->SetFont((wxFont const &)*arg2);
5298
5299 wxPyEndAllowThreads(__tstate);
5300 if (PyErr_Occurred()) SWIG_fail;
5301 }
5302 Py_INCREF(Py_None); resultobj = Py_None;
5303 return resultobj;
5304 fail:
5305 return NULL;
5306 }
5307
5308
5309 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5310 PyObject *resultobj;
5311 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5312 int arg2 ;
5313 int arg3 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 PyObject * obj2 = 0 ;
5317 char *kwnames[] = {
5318 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5319 };
5320
5321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5323 if (SWIG_arg_fail(1)) SWIG_fail;
5324 {
5325 arg2 = (int)(SWIG_As_int(obj1));
5326 if (SWIG_arg_fail(2)) SWIG_fail;
5327 }
5328 {
5329 arg3 = (int)(SWIG_As_int(obj2));
5330 if (SWIG_arg_fail(3)) SWIG_fail;
5331 }
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 (arg1)->SetAlignment(arg2,arg3);
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 Py_INCREF(Py_None); resultobj = Py_None;
5340 return resultobj;
5341 fail:
5342 return NULL;
5343 }
5344
5345
5346 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5347 PyObject *resultobj;
5348 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5349 int arg2 ;
5350 int arg3 ;
5351 PyObject * obj0 = 0 ;
5352 PyObject * obj1 = 0 ;
5353 PyObject * obj2 = 0 ;
5354 char *kwnames[] = {
5355 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5356 };
5357
5358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5360 if (SWIG_arg_fail(1)) SWIG_fail;
5361 {
5362 arg2 = (int)(SWIG_As_int(obj1));
5363 if (SWIG_arg_fail(2)) SWIG_fail;
5364 }
5365 {
5366 arg3 = (int)(SWIG_As_int(obj2));
5367 if (SWIG_arg_fail(3)) SWIG_fail;
5368 }
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 (arg1)->SetSize(arg2,arg3);
5372
5373 wxPyEndAllowThreads(__tstate);
5374 if (PyErr_Occurred()) SWIG_fail;
5375 }
5376 Py_INCREF(Py_None); resultobj = Py_None;
5377 return resultobj;
5378 fail:
5379 return NULL;
5380 }
5381
5382
5383 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5384 PyObject *resultobj;
5385 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5386 bool arg2 = (bool) true ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 char *kwnames[] = {
5390 (char *) "self",(char *) "allow", NULL
5391 };
5392
5393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5395 if (SWIG_arg_fail(1)) SWIG_fail;
5396 if (obj1) {
5397 {
5398 arg2 = (bool)(SWIG_As_bool(obj1));
5399 if (SWIG_arg_fail(2)) SWIG_fail;
5400 }
5401 }
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 (arg1)->SetOverflow(arg2);
5405
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 Py_INCREF(Py_None); resultobj = Py_None;
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj;
5418 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5419 bool arg2 = (bool) true ;
5420 PyObject * obj0 = 0 ;
5421 PyObject * obj1 = 0 ;
5422 char *kwnames[] = {
5423 (char *) "self",(char *) "isReadOnly", NULL
5424 };
5425
5426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5428 if (SWIG_arg_fail(1)) SWIG_fail;
5429 if (obj1) {
5430 {
5431 arg2 = (bool)(SWIG_As_bool(obj1));
5432 if (SWIG_arg_fail(2)) SWIG_fail;
5433 }
5434 }
5435 {
5436 PyThreadState* __tstate = wxPyBeginAllowThreads();
5437 (arg1)->SetReadOnly(arg2);
5438
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 Py_INCREF(Py_None); resultobj = Py_None;
5443 return resultobj;
5444 fail:
5445 return NULL;
5446 }
5447
5448
5449 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5450 PyObject *resultobj;
5451 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5452 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5453 PyObject * obj0 = 0 ;
5454 PyObject * obj1 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self",(char *) "renderer", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5463 if (SWIG_arg_fail(2)) SWIG_fail;
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 (arg1)->SetRenderer(arg2);
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 Py_INCREF(Py_None); resultobj = Py_None;
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5481 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5482 PyObject * obj0 = 0 ;
5483 PyObject * obj1 = 0 ;
5484 char *kwnames[] = {
5485 (char *) "self",(char *) "editor", NULL
5486 };
5487
5488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5490 if (SWIG_arg_fail(1)) SWIG_fail;
5491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5492 if (SWIG_arg_fail(2)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 (arg1)->SetEditor(arg2);
5496
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 Py_INCREF(Py_None); resultobj = Py_None;
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj;
5509 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5510 wxGridCellAttr::wxAttrKind arg2 ;
5511 PyObject * obj0 = 0 ;
5512 PyObject * obj1 = 0 ;
5513 char *kwnames[] = {
5514 (char *) "self",(char *) "kind", NULL
5515 };
5516
5517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5519 if (SWIG_arg_fail(1)) SWIG_fail;
5520 {
5521 arg2 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj1));
5522 if (SWIG_arg_fail(2)) SWIG_fail;
5523 }
5524 {
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 (arg1)->SetKind((wxGridCellAttr::wxAttrKind )arg2);
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 Py_INCREF(Py_None); resultobj = Py_None;
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5539 PyObject *resultobj;
5540 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5541 bool result;
5542 PyObject * obj0 = 0 ;
5543 char *kwnames[] = {
5544 (char *) "self", NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5549 if (SWIG_arg_fail(1)) SWIG_fail;
5550 {
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 {
5558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5559 }
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5569 bool result;
5570 PyObject * obj0 = 0 ;
5571 char *kwnames[] = {
5572 (char *) "self", NULL
5573 };
5574
5575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5577 if (SWIG_arg_fail(1)) SWIG_fail;
5578 {
5579 PyThreadState* __tstate = wxPyBeginAllowThreads();
5580 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5581
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 {
5586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5587 }
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5595 PyObject *resultobj;
5596 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5597 bool result;
5598 PyObject * obj0 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 {
5614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5615 }
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj;
5624 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5625 bool result;
5626 PyObject * obj0 = 0 ;
5627 char *kwnames[] = {
5628 (char *) "self", NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5633 if (SWIG_arg_fail(1)) SWIG_fail;
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5653 bool result;
5654 PyObject * obj0 = 0 ;
5655 char *kwnames[] = {
5656 (char *) "self", NULL
5657 };
5658
5659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5661 if (SWIG_arg_fail(1)) SWIG_fail;
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj;
5680 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5681 bool result;
5682 PyObject * obj0 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 {
5698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5699 }
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5707 PyObject *resultobj;
5708 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5709 bool result;
5710 PyObject * obj0 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 {
5726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5727 }
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5735 PyObject *resultobj;
5736 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5737 bool result;
5738 PyObject * obj0 = 0 ;
5739 char *kwnames[] = {
5740 (char *) "self", NULL
5741 };
5742
5743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5745 if (SWIG_arg_fail(1)) SWIG_fail;
5746 {
5747 PyThreadState* __tstate = wxPyBeginAllowThreads();
5748 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5749
5750 wxPyEndAllowThreads(__tstate);
5751 if (PyErr_Occurred()) SWIG_fail;
5752 }
5753 {
5754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5755 }
5756 return resultobj;
5757 fail:
5758 return NULL;
5759 }
5760
5761
5762 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5763 PyObject *resultobj;
5764 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5765 wxColour result;
5766 PyObject * obj0 = 0 ;
5767 char *kwnames[] = {
5768 (char *) "self", NULL
5769 };
5770
5771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5773 if (SWIG_arg_fail(1)) SWIG_fail;
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5777
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 {
5782 wxColour * resultptr;
5783 resultptr = new wxColour((wxColour &)(result));
5784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5785 }
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj;
5794 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5795 wxColour result;
5796 PyObject * obj0 = 0 ;
5797 char *kwnames[] = {
5798 (char *) "self", NULL
5799 };
5800
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 {
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 {
5812 wxColour * resultptr;
5813 resultptr = new wxColour((wxColour &)(result));
5814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5815 }
5816 return resultobj;
5817 fail:
5818 return NULL;
5819 }
5820
5821
5822 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5823 PyObject *resultobj;
5824 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5825 wxFont result;
5826 PyObject * obj0 = 0 ;
5827 char *kwnames[] = {
5828 (char *) "self", NULL
5829 };
5830
5831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
5832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5833 if (SWIG_arg_fail(1)) SWIG_fail;
5834 {
5835 PyThreadState* __tstate = wxPyBeginAllowThreads();
5836 result = ((wxGridCellAttr const *)arg1)->GetFont();
5837
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 {
5842 wxFont * resultptr;
5843 resultptr = new wxFont((wxFont &)(result));
5844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
5845 }
5846 return resultobj;
5847 fail:
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj;
5854 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5855 int *arg2 = (int *) 0 ;
5856 int *arg3 = (int *) 0 ;
5857 int temp2 ;
5858 int res2 = 0 ;
5859 int temp3 ;
5860 int res3 = 0 ;
5861 PyObject * obj0 = 0 ;
5862 char *kwnames[] = {
5863 (char *) "self", NULL
5864 };
5865
5866 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5867 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
5869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5870 if (SWIG_arg_fail(1)) SWIG_fail;
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
5874
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 Py_INCREF(Py_None); resultobj = Py_None;
5879 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5880 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5881 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5882 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5883 return resultobj;
5884 fail:
5885 return NULL;
5886 }
5887
5888
5889 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5890 PyObject *resultobj;
5891 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5892 int *arg2 = (int *) 0 ;
5893 int *arg3 = (int *) 0 ;
5894 int temp2 ;
5895 int res2 = 0 ;
5896 int temp3 ;
5897 int res3 = 0 ;
5898 PyObject * obj0 = 0 ;
5899 char *kwnames[] = {
5900 (char *) "self", NULL
5901 };
5902
5903 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5904 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
5906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5907 if (SWIG_arg_fail(1)) SWIG_fail;
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
5911
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 Py_INCREF(Py_None); resultobj = Py_None;
5916 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5917 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5918 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5919 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5929 bool result;
5930 PyObject * obj0 = 0 ;
5931 char *kwnames[] = {
5932 (char *) "self", NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
5936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5937 if (SWIG_arg_fail(1)) SWIG_fail;
5938 {
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
5941
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 {
5946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5947 }
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5955 PyObject *resultobj;
5956 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5957 wxGrid *arg2 = (wxGrid *) 0 ;
5958 int arg3 ;
5959 int arg4 ;
5960 wxGridCellRenderer *result;
5961 PyObject * obj0 = 0 ;
5962 PyObject * obj1 = 0 ;
5963 PyObject * obj2 = 0 ;
5964 PyObject * obj3 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5973 if (SWIG_arg_fail(2)) SWIG_fail;
5974 {
5975 arg3 = (int)(SWIG_As_int(obj2));
5976 if (SWIG_arg_fail(3)) SWIG_fail;
5977 }
5978 {
5979 arg4 = (int)(SWIG_As_int(obj3));
5980 if (SWIG_arg_fail(4)) SWIG_fail;
5981 }
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 {
5990 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
5991 }
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6001 wxGrid *arg2 = (wxGrid *) 0 ;
6002 int arg3 ;
6003 int arg4 ;
6004 wxGridCellEditor *result;
6005 PyObject * obj0 = 0 ;
6006 PyObject * obj1 = 0 ;
6007 PyObject * obj2 = 0 ;
6008 PyObject * obj3 = 0 ;
6009 char *kwnames[] = {
6010 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6015 if (SWIG_arg_fail(1)) SWIG_fail;
6016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6017 if (SWIG_arg_fail(2)) SWIG_fail;
6018 {
6019 arg3 = (int)(SWIG_As_int(obj2));
6020 if (SWIG_arg_fail(3)) SWIG_fail;
6021 }
6022 {
6023 arg4 = (int)(SWIG_As_int(obj3));
6024 if (SWIG_arg_fail(4)) SWIG_fail;
6025 }
6026 {
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 resultobj = wxPyMake_wxGridCellEditor(result, 0);
6035 }
6036 return resultobj;
6037 fail:
6038 return NULL;
6039 }
6040
6041
6042 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj;
6044 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6045 bool result;
6046 PyObject * obj0 = 0 ;
6047 char *kwnames[] = {
6048 (char *) "self", NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6053 if (SWIG_arg_fail(1)) SWIG_fail;
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6073 wxGridCellAttr::wxAttrKind result;
6074 PyObject * obj0 = 0 ;
6075 char *kwnames[] = {
6076 (char *) "self", NULL
6077 };
6078
6079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6081 if (SWIG_arg_fail(1)) SWIG_fail;
6082 {
6083 PyThreadState* __tstate = wxPyBeginAllowThreads();
6084 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6085
6086 wxPyEndAllowThreads(__tstate);
6087 if (PyErr_Occurred()) SWIG_fail;
6088 }
6089 resultobj = SWIG_From_int((result));
6090 return resultobj;
6091 fail:
6092 return NULL;
6093 }
6094
6095
6096 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6097 PyObject *resultobj;
6098 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6099 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self",(char *) "defAttr", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6110 if (SWIG_arg_fail(2)) SWIG_fail;
6111 {
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 (arg1)->SetDefAttr(arg2);
6114
6115 wxPyEndAllowThreads(__tstate);
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 Py_INCREF(Py_None); resultobj = Py_None;
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6126 PyObject *obj;
6127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6128 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6129 Py_INCREF(obj);
6130 return Py_BuildValue((char *)"");
6131 }
6132 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxGridCellAttrProvider *result;
6135 char *kwnames[] = {
6136 NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6140 {
6141 PyThreadState* __tstate = wxPyBeginAllowThreads();
6142 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6143
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 {
6148 resultobj = wxPyMake_wxGridCellAttrProvider(result, 1);
6149 }
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6157 PyObject *resultobj;
6158 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6159 PyObject *arg2 = (PyObject *) 0 ;
6160 PyObject * obj0 = 0 ;
6161 PyObject * obj1 = 0 ;
6162 char *kwnames[] = {
6163 (char *) "self",(char *) "_self", NULL
6164 };
6165
6166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6168 if (SWIG_arg_fail(1)) SWIG_fail;
6169 arg2 = obj1;
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 Py_INCREF(Py_None); resultobj = Py_None;
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj;
6186 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6187 int arg2 ;
6188 int arg3 ;
6189 wxGridCellAttr::wxAttrKind arg4 ;
6190 wxGridCellAttr *result;
6191 PyObject * obj0 = 0 ;
6192 PyObject * obj1 = 0 ;
6193 PyObject * obj2 = 0 ;
6194 PyObject * obj3 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 {
6203 arg2 = (int)(SWIG_As_int(obj1));
6204 if (SWIG_arg_fail(2)) SWIG_fail;
6205 }
6206 {
6207 arg3 = (int)(SWIG_As_int(obj2));
6208 if (SWIG_arg_fail(3)) SWIG_fail;
6209 }
6210 {
6211 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6212 if (SWIG_arg_fail(4)) SWIG_fail;
6213 }
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6217
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 {
6222 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6223 }
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6233 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6234 int arg3 ;
6235 int arg4 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 PyObject * obj2 = 0 ;
6239 PyObject * obj3 = 0 ;
6240 char *kwnames[] = {
6241 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6246 if (SWIG_arg_fail(1)) SWIG_fail;
6247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6248 if (SWIG_arg_fail(2)) SWIG_fail;
6249 {
6250 arg3 = (int)(SWIG_As_int(obj2));
6251 if (SWIG_arg_fail(3)) SWIG_fail;
6252 }
6253 {
6254 arg4 = (int)(SWIG_As_int(obj3));
6255 if (SWIG_arg_fail(4)) SWIG_fail;
6256 }
6257 {
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 (arg1)->SetAttr(arg2,arg3,arg4);
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 Py_INCREF(Py_None); resultobj = Py_None;
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6274 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6275 int arg3 ;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 PyObject * obj2 = 0 ;
6279 char *kwnames[] = {
6280 (char *) "self",(char *) "attr",(char *) "row", NULL
6281 };
6282
6283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6285 if (SWIG_arg_fail(1)) SWIG_fail;
6286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6287 if (SWIG_arg_fail(2)) SWIG_fail;
6288 {
6289 arg3 = (int)(SWIG_As_int(obj2));
6290 if (SWIG_arg_fail(3)) SWIG_fail;
6291 }
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 (arg1)->SetRowAttr(arg2,arg3);
6295
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 Py_INCREF(Py_None); resultobj = Py_None;
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6309 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6310 int arg3 ;
6311 PyObject * obj0 = 0 ;
6312 PyObject * obj1 = 0 ;
6313 PyObject * obj2 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self",(char *) "attr",(char *) "col", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6322 if (SWIG_arg_fail(2)) SWIG_fail;
6323 {
6324 arg3 = (int)(SWIG_As_int(obj2));
6325 if (SWIG_arg_fail(3)) SWIG_fail;
6326 }
6327 {
6328 PyThreadState* __tstate = wxPyBeginAllowThreads();
6329 (arg1)->SetColAttr(arg2,arg3);
6330
6331 wxPyEndAllowThreads(__tstate);
6332 if (PyErr_Occurred()) SWIG_fail;
6333 }
6334 Py_INCREF(Py_None); resultobj = Py_None;
6335 return resultobj;
6336 fail:
6337 return NULL;
6338 }
6339
6340
6341 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6342 PyObject *resultobj;
6343 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6344 size_t arg2 ;
6345 int arg3 ;
6346 PyObject * obj0 = 0 ;
6347 PyObject * obj1 = 0 ;
6348 PyObject * obj2 = 0 ;
6349 char *kwnames[] = {
6350 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6351 };
6352
6353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6355 if (SWIG_arg_fail(1)) SWIG_fail;
6356 {
6357 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6358 if (SWIG_arg_fail(2)) SWIG_fail;
6359 }
6360 {
6361 arg3 = (int)(SWIG_As_int(obj2));
6362 if (SWIG_arg_fail(3)) SWIG_fail;
6363 }
6364 {
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 (arg1)->UpdateAttrRows(arg2,arg3);
6367
6368 wxPyEndAllowThreads(__tstate);
6369 if (PyErr_Occurred()) SWIG_fail;
6370 }
6371 Py_INCREF(Py_None); resultobj = Py_None;
6372 return resultobj;
6373 fail:
6374 return NULL;
6375 }
6376
6377
6378 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6379 PyObject *resultobj;
6380 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6381 size_t arg2 ;
6382 int arg3 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 char *kwnames[] = {
6387 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6388 };
6389
6390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6392 if (SWIG_arg_fail(1)) SWIG_fail;
6393 {
6394 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6395 if (SWIG_arg_fail(2)) SWIG_fail;
6396 }
6397 {
6398 arg3 = (int)(SWIG_As_int(obj2));
6399 if (SWIG_arg_fail(3)) SWIG_fail;
6400 }
6401 {
6402 PyThreadState* __tstate = wxPyBeginAllowThreads();
6403 (arg1)->UpdateAttrCols(arg2,arg3);
6404
6405 wxPyEndAllowThreads(__tstate);
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 Py_INCREF(Py_None); resultobj = Py_None;
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6416 PyObject *obj;
6417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6418 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6419 Py_INCREF(obj);
6420 return Py_BuildValue((char *)"");
6421 }
6422 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxPyGridCellAttrProvider *result;
6425 char *kwnames[] = {
6426 NULL
6427 };
6428
6429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6430 {
6431 PyThreadState* __tstate = wxPyBeginAllowThreads();
6432 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6433
6434 wxPyEndAllowThreads(__tstate);
6435 if (PyErr_Occurred()) SWIG_fail;
6436 }
6437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6438 return resultobj;
6439 fail:
6440 return NULL;
6441 }
6442
6443
6444 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6445 PyObject *resultobj;
6446 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6447 PyObject *arg2 = (PyObject *) 0 ;
6448 PyObject *arg3 = (PyObject *) 0 ;
6449 PyObject * obj0 = 0 ;
6450 PyObject * obj1 = 0 ;
6451 PyObject * obj2 = 0 ;
6452 char *kwnames[] = {
6453 (char *) "self",(char *) "self",(char *) "_class", NULL
6454 };
6455
6456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6458 if (SWIG_arg_fail(1)) SWIG_fail;
6459 arg2 = obj1;
6460 arg3 = obj2;
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 (arg1)->_setCallbackInfo(arg2,arg3);
6464
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 Py_INCREF(Py_None); resultobj = Py_None;
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_PyGridCellAttrProvider_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj;
6477 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6478 int arg2 ;
6479 int arg3 ;
6480 wxGridCellAttr::wxAttrKind arg4 ;
6481 wxGridCellAttr *result;
6482 PyObject * obj0 = 0 ;
6483 PyObject * obj1 = 0 ;
6484 PyObject * obj2 = 0 ;
6485 PyObject * obj3 = 0 ;
6486 char *kwnames[] = {
6487 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6488 };
6489
6490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6492 if (SWIG_arg_fail(1)) SWIG_fail;
6493 {
6494 arg2 = (int)(SWIG_As_int(obj1));
6495 if (SWIG_arg_fail(2)) SWIG_fail;
6496 }
6497 {
6498 arg3 = (int)(SWIG_As_int(obj2));
6499 if (SWIG_arg_fail(3)) SWIG_fail;
6500 }
6501 {
6502 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6503 if (SWIG_arg_fail(4)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 {
6513 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6514 }
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_PyGridCellAttrProvider_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj;
6523 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6524 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6525 int arg3 ;
6526 int arg4 ;
6527 PyObject * obj0 = 0 ;
6528 PyObject * obj1 = 0 ;
6529 PyObject * obj2 = 0 ;
6530 PyObject * obj3 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6533 };
6534
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(2)) SWIG_fail;
6540 {
6541 arg3 = (int)(SWIG_As_int(obj2));
6542 if (SWIG_arg_fail(3)) SWIG_fail;
6543 }
6544 {
6545 arg4 = (int)(SWIG_As_int(obj3));
6546 if (SWIG_arg_fail(4)) SWIG_fail;
6547 }
6548 {
6549 PyThreadState* __tstate = wxPyBeginAllowThreads();
6550 (arg1)->base_SetAttr(arg2,arg3,arg4);
6551
6552 wxPyEndAllowThreads(__tstate);
6553 if (PyErr_Occurred()) SWIG_fail;
6554 }
6555 Py_INCREF(Py_None); resultobj = Py_None;
6556 return resultobj;
6557 fail:
6558 return NULL;
6559 }
6560
6561
6562 static PyObject *_wrap_PyGridCellAttrProvider_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6563 PyObject *resultobj;
6564 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6565 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6566 int arg3 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 PyObject * obj2 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "self",(char *) "attr",(char *) "row", NULL
6572 };
6573
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6576 if (SWIG_arg_fail(1)) SWIG_fail;
6577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6578 if (SWIG_arg_fail(2)) SWIG_fail;
6579 {
6580 arg3 = (int)(SWIG_As_int(obj2));
6581 if (SWIG_arg_fail(3)) SWIG_fail;
6582 }
6583 {
6584 PyThreadState* __tstate = wxPyBeginAllowThreads();
6585 (arg1)->base_SetRowAttr(arg2,arg3);
6586
6587 wxPyEndAllowThreads(__tstate);
6588 if (PyErr_Occurred()) SWIG_fail;
6589 }
6590 Py_INCREF(Py_None); resultobj = Py_None;
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 static PyObject *_wrap_PyGridCellAttrProvider_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6598 PyObject *resultobj;
6599 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6600 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6601 int arg3 ;
6602 PyObject * obj0 = 0 ;
6603 PyObject * obj1 = 0 ;
6604 PyObject * obj2 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self",(char *) "attr",(char *) "col", NULL
6607 };
6608
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6613 if (SWIG_arg_fail(2)) SWIG_fail;
6614 {
6615 arg3 = (int)(SWIG_As_int(obj2));
6616 if (SWIG_arg_fail(3)) SWIG_fail;
6617 }
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 (arg1)->base_SetColAttr(arg2,arg3);
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 Py_INCREF(Py_None); resultobj = Py_None;
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6633 PyObject *obj;
6634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6635 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6636 Py_INCREF(obj);
6637 return Py_BuildValue((char *)"");
6638 }
6639 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6640 PyObject *resultobj;
6641 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6642 PyObject *arg2 = (PyObject *) 0 ;
6643 PyObject * obj0 = 0 ;
6644 PyObject * obj1 = 0 ;
6645 char *kwnames[] = {
6646 (char *) "self",(char *) "_self", NULL
6647 };
6648
6649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6651 if (SWIG_arg_fail(1)) SWIG_fail;
6652 arg2 = obj1;
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 wxGridTableBase__setOORInfo(arg1,arg2);
6656
6657 wxPyEndAllowThreads(__tstate);
6658 if (PyErr_Occurred()) SWIG_fail;
6659 }
6660 Py_INCREF(Py_None); resultobj = Py_None;
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6670 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6671 PyObject * obj0 = 0 ;
6672 PyObject * obj1 = 0 ;
6673 char *kwnames[] = {
6674 (char *) "self",(char *) "attrProvider", NULL
6675 };
6676
6677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6679 if (SWIG_arg_fail(1)) SWIG_fail;
6680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6681 if (SWIG_arg_fail(2)) SWIG_fail;
6682 {
6683 PyThreadState* __tstate = wxPyBeginAllowThreads();
6684 (arg1)->SetAttrProvider(arg2);
6685
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 Py_INCREF(Py_None); resultobj = Py_None;
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 static PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6697 PyObject *resultobj;
6698 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6699 wxGridCellAttrProvider *result;
6700 PyObject * obj0 = 0 ;
6701 char *kwnames[] = {
6702 (char *) "self", NULL
6703 };
6704
6705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6707 if (SWIG_arg_fail(1)) SWIG_fail;
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 {
6716 resultobj = wxPyMake_wxGridCellAttrProvider(result, 0);
6717 }
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6727 wxGrid *arg2 = (wxGrid *) 0 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char *kwnames[] = {
6731 (char *) "self",(char *) "grid", NULL
6732 };
6733
6734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6736 if (SWIG_arg_fail(1)) SWIG_fail;
6737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 {
6740 PyThreadState* __tstate = wxPyBeginAllowThreads();
6741 (arg1)->SetView(arg2);
6742
6743 wxPyEndAllowThreads(__tstate);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 Py_INCREF(Py_None); resultobj = Py_None;
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj;
6755 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6756 wxGrid *result;
6757 PyObject * obj0 = 0 ;
6758 char *kwnames[] = {
6759 (char *) "self", NULL
6760 };
6761
6762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 {
6773 resultobj = wxPyMake_wxObject(result, 0);
6774 }
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6784 int result;
6785 PyObject * obj0 = 0 ;
6786 char *kwnames[] = {
6787 (char *) "self", NULL
6788 };
6789
6790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6792 if (SWIG_arg_fail(1)) SWIG_fail;
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)(arg1)->GetNumberRows();
6796
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 {
6801 resultobj = SWIG_From_int((int)(result));
6802 }
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj;
6811 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6812 int result;
6813 PyObject * obj0 = 0 ;
6814 char *kwnames[] = {
6815 (char *) "self", NULL
6816 };
6817
6818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
6819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6820 if (SWIG_arg_fail(1)) SWIG_fail;
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 result = (int)(arg1)->GetNumberCols();
6824
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 {
6829 resultobj = SWIG_From_int((int)(result));
6830 }
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
6838 PyObject *resultobj;
6839 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6840 int arg2 ;
6841 int arg3 ;
6842 bool result;
6843 PyObject * obj0 = 0 ;
6844 PyObject * obj1 = 0 ;
6845 PyObject * obj2 = 0 ;
6846 char *kwnames[] = {
6847 (char *) "self",(char *) "row",(char *) "col", NULL
6848 };
6849
6850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
6851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6852 if (SWIG_arg_fail(1)) SWIG_fail;
6853 {
6854 arg2 = (int)(SWIG_As_int(obj1));
6855 if (SWIG_arg_fail(2)) SWIG_fail;
6856 }
6857 {
6858 arg3 = (int)(SWIG_As_int(obj2));
6859 if (SWIG_arg_fail(3)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6870 }
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6880 int arg2 ;
6881 int arg3 ;
6882 wxString result;
6883 PyObject * obj0 = 0 ;
6884 PyObject * obj1 = 0 ;
6885 PyObject * obj2 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self",(char *) "row",(char *) "col", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 arg2 = (int)(SWIG_As_int(obj1));
6895 if (SWIG_arg_fail(2)) SWIG_fail;
6896 }
6897 {
6898 arg3 = (int)(SWIG_As_int(obj2));
6899 if (SWIG_arg_fail(3)) SWIG_fail;
6900 }
6901 {
6902 PyThreadState* __tstate = wxPyBeginAllowThreads();
6903 result = (arg1)->GetValue(arg2,arg3);
6904
6905 wxPyEndAllowThreads(__tstate);
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 {
6909 #if wxUSE_UNICODE
6910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6911 #else
6912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6913 #endif
6914 }
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj;
6923 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6924 int arg2 ;
6925 int arg3 ;
6926 wxString *arg4 = 0 ;
6927 bool temp4 = false ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 PyObject * obj2 = 0 ;
6931 PyObject * obj3 = 0 ;
6932 char *kwnames[] = {
6933 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
6934 };
6935
6936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 {
6940 arg2 = (int)(SWIG_As_int(obj1));
6941 if (SWIG_arg_fail(2)) SWIG_fail;
6942 }
6943 {
6944 arg3 = (int)(SWIG_As_int(obj2));
6945 if (SWIG_arg_fail(3)) SWIG_fail;
6946 }
6947 {
6948 arg4 = wxString_in_helper(obj3);
6949 if (arg4 == NULL) SWIG_fail;
6950 temp4 = true;
6951 }
6952 {
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
6955
6956 wxPyEndAllowThreads(__tstate);
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 Py_INCREF(Py_None); resultobj = Py_None;
6960 {
6961 if (temp4)
6962 delete arg4;
6963 }
6964 return resultobj;
6965 fail:
6966 {
6967 if (temp4)
6968 delete arg4;
6969 }
6970 return NULL;
6971 }
6972
6973
6974 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj;
6976 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6977 int arg2 ;
6978 int arg3 ;
6979 wxString result;
6980 PyObject * obj0 = 0 ;
6981 PyObject * obj1 = 0 ;
6982 PyObject * obj2 = 0 ;
6983 char *kwnames[] = {
6984 (char *) "self",(char *) "row",(char *) "col", NULL
6985 };
6986
6987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
6988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6989 if (SWIG_arg_fail(1)) SWIG_fail;
6990 {
6991 arg2 = (int)(SWIG_As_int(obj1));
6992 if (SWIG_arg_fail(2)) SWIG_fail;
6993 }
6994 {
6995 arg3 = (int)(SWIG_As_int(obj2));
6996 if (SWIG_arg_fail(3)) SWIG_fail;
6997 }
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 result = (arg1)->GetTypeName(arg2,arg3);
7001
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 {
7006 #if wxUSE_UNICODE
7007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7008 #else
7009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7010 #endif
7011 }
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7021 int arg2 ;
7022 int arg3 ;
7023 wxString *arg4 = 0 ;
7024 bool result;
7025 bool temp4 = false ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 PyObject * obj2 = 0 ;
7029 PyObject * obj3 = 0 ;
7030 char *kwnames[] = {
7031 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7032 };
7033
7034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7036 if (SWIG_arg_fail(1)) SWIG_fail;
7037 {
7038 arg2 = (int)(SWIG_As_int(obj1));
7039 if (SWIG_arg_fail(2)) SWIG_fail;
7040 }
7041 {
7042 arg3 = (int)(SWIG_As_int(obj2));
7043 if (SWIG_arg_fail(3)) SWIG_fail;
7044 }
7045 {
7046 arg4 = wxString_in_helper(obj3);
7047 if (arg4 == NULL) SWIG_fail;
7048 temp4 = true;
7049 }
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7053
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 {
7058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7059 }
7060 {
7061 if (temp4)
7062 delete arg4;
7063 }
7064 return resultobj;
7065 fail:
7066 {
7067 if (temp4)
7068 delete arg4;
7069 }
7070 return NULL;
7071 }
7072
7073
7074 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj;
7076 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7077 int arg2 ;
7078 int arg3 ;
7079 wxString *arg4 = 0 ;
7080 bool result;
7081 bool temp4 = false ;
7082 PyObject * obj0 = 0 ;
7083 PyObject * obj1 = 0 ;
7084 PyObject * obj2 = 0 ;
7085 PyObject * obj3 = 0 ;
7086 char *kwnames[] = {
7087 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7088 };
7089
7090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7092 if (SWIG_arg_fail(1)) SWIG_fail;
7093 {
7094 arg2 = (int)(SWIG_As_int(obj1));
7095 if (SWIG_arg_fail(2)) SWIG_fail;
7096 }
7097 {
7098 arg3 = (int)(SWIG_As_int(obj2));
7099 if (SWIG_arg_fail(3)) SWIG_fail;
7100 }
7101 {
7102 arg4 = wxString_in_helper(obj3);
7103 if (arg4 == NULL) SWIG_fail;
7104 temp4 = true;
7105 }
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7109
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 {
7114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7115 }
7116 {
7117 if (temp4)
7118 delete arg4;
7119 }
7120 return resultobj;
7121 fail:
7122 {
7123 if (temp4)
7124 delete arg4;
7125 }
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj;
7132 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7133 int arg2 ;
7134 int arg3 ;
7135 long result;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 PyObject * obj2 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self",(char *) "row",(char *) "col", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 {
7147 arg2 = (int)(SWIG_As_int(obj1));
7148 if (SWIG_arg_fail(2)) SWIG_fail;
7149 }
7150 {
7151 arg3 = (int)(SWIG_As_int(obj2));
7152 if (SWIG_arg_fail(3)) SWIG_fail;
7153 }
7154 {
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7157
7158 wxPyEndAllowThreads(__tstate);
7159 if (PyErr_Occurred()) SWIG_fail;
7160 }
7161 {
7162 resultobj = SWIG_From_long((long)(result));
7163 }
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7173 int arg2 ;
7174 int arg3 ;
7175 double result;
7176 PyObject * obj0 = 0 ;
7177 PyObject * obj1 = 0 ;
7178 PyObject * obj2 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self",(char *) "row",(char *) "col", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 {
7187 arg2 = (int)(SWIG_As_int(obj1));
7188 if (SWIG_arg_fail(2)) SWIG_fail;
7189 }
7190 {
7191 arg3 = (int)(SWIG_As_int(obj2));
7192 if (SWIG_arg_fail(3)) SWIG_fail;
7193 }
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7197
7198 wxPyEndAllowThreads(__tstate);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 {
7202 resultobj = SWIG_From_double((double)(result));
7203 }
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj;
7212 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7213 int arg2 ;
7214 int arg3 ;
7215 bool result;
7216 PyObject * obj0 = 0 ;
7217 PyObject * obj1 = 0 ;
7218 PyObject * obj2 = 0 ;
7219 char *kwnames[] = {
7220 (char *) "self",(char *) "row",(char *) "col", NULL
7221 };
7222
7223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7225 if (SWIG_arg_fail(1)) SWIG_fail;
7226 {
7227 arg2 = (int)(SWIG_As_int(obj1));
7228 if (SWIG_arg_fail(2)) SWIG_fail;
7229 }
7230 {
7231 arg3 = (int)(SWIG_As_int(obj2));
7232 if (SWIG_arg_fail(3)) SWIG_fail;
7233 }
7234 {
7235 PyThreadState* __tstate = wxPyBeginAllowThreads();
7236 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7237
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 {
7242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7243 }
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj;
7252 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7253 int arg2 ;
7254 int arg3 ;
7255 long arg4 ;
7256 PyObject * obj0 = 0 ;
7257 PyObject * obj1 = 0 ;
7258 PyObject * obj2 = 0 ;
7259 PyObject * obj3 = 0 ;
7260 char *kwnames[] = {
7261 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7262 };
7263
7264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7266 if (SWIG_arg_fail(1)) SWIG_fail;
7267 {
7268 arg2 = (int)(SWIG_As_int(obj1));
7269 if (SWIG_arg_fail(2)) SWIG_fail;
7270 }
7271 {
7272 arg3 = (int)(SWIG_As_int(obj2));
7273 if (SWIG_arg_fail(3)) SWIG_fail;
7274 }
7275 {
7276 arg4 = (long)(SWIG_As_long(obj3));
7277 if (SWIG_arg_fail(4)) SWIG_fail;
7278 }
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7282
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 Py_INCREF(Py_None); resultobj = Py_None;
7287 return resultobj;
7288 fail:
7289 return NULL;
7290 }
7291
7292
7293 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj;
7295 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7296 int arg2 ;
7297 int arg3 ;
7298 double arg4 ;
7299 PyObject * obj0 = 0 ;
7300 PyObject * obj1 = 0 ;
7301 PyObject * obj2 = 0 ;
7302 PyObject * obj3 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 arg2 = (int)(SWIG_As_int(obj1));
7312 if (SWIG_arg_fail(2)) SWIG_fail;
7313 }
7314 {
7315 arg3 = (int)(SWIG_As_int(obj2));
7316 if (SWIG_arg_fail(3)) SWIG_fail;
7317 }
7318 {
7319 arg4 = (double)(SWIG_As_double(obj3));
7320 if (SWIG_arg_fail(4)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7325
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 Py_INCREF(Py_None); resultobj = Py_None;
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj;
7338 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7339 int arg2 ;
7340 int arg3 ;
7341 bool arg4 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 PyObject * obj2 = 0 ;
7345 PyObject * obj3 = 0 ;
7346 char *kwnames[] = {
7347 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7348 };
7349
7350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 {
7354 arg2 = (int)(SWIG_As_int(obj1));
7355 if (SWIG_arg_fail(2)) SWIG_fail;
7356 }
7357 {
7358 arg3 = (int)(SWIG_As_int(obj2));
7359 if (SWIG_arg_fail(3)) SWIG_fail;
7360 }
7361 {
7362 arg4 = (bool)(SWIG_As_bool(obj3));
7363 if (SWIG_arg_fail(4)) SWIG_fail;
7364 }
7365 {
7366 PyThreadState* __tstate = wxPyBeginAllowThreads();
7367 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7368
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 Py_INCREF(Py_None); resultobj = Py_None;
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7382 PyObject * obj0 = 0 ;
7383 char *kwnames[] = {
7384 (char *) "self", NULL
7385 };
7386
7387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7389 if (SWIG_arg_fail(1)) SWIG_fail;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 (arg1)->Clear();
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 Py_INCREF(Py_None); resultobj = Py_None;
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj;
7406 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7407 size_t arg2 = (size_t) 0 ;
7408 size_t arg3 = (size_t) 1 ;
7409 bool result;
7410 PyObject * obj0 = 0 ;
7411 PyObject * obj1 = 0 ;
7412 PyObject * obj2 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 if (obj1) {
7421 {
7422 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7423 if (SWIG_arg_fail(2)) SWIG_fail;
7424 }
7425 }
7426 if (obj2) {
7427 {
7428 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7429 if (SWIG_arg_fail(3)) SWIG_fail;
7430 }
7431 }
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 result = (bool)(arg1)->InsertRows(arg2,arg3);
7435
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj;
7450 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7451 size_t arg2 = (size_t) 1 ;
7452 bool result;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 char *kwnames[] = {
7456 (char *) "self",(char *) "numRows", NULL
7457 };
7458
7459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7461 if (SWIG_arg_fail(1)) SWIG_fail;
7462 if (obj1) {
7463 {
7464 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7465 if (SWIG_arg_fail(2)) SWIG_fail;
7466 }
7467 }
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 result = (bool)(arg1)->AppendRows(arg2);
7471
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 {
7476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7477 }
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj;
7486 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7487 size_t arg2 = (size_t) 0 ;
7488 size_t arg3 = (size_t) 1 ;
7489 bool result;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 PyObject * obj2 = 0 ;
7493 char *kwnames[] = {
7494 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7495 };
7496
7497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7499 if (SWIG_arg_fail(1)) SWIG_fail;
7500 if (obj1) {
7501 {
7502 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7503 if (SWIG_arg_fail(2)) SWIG_fail;
7504 }
7505 }
7506 if (obj2) {
7507 {
7508 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7509 if (SWIG_arg_fail(3)) SWIG_fail;
7510 }
7511 }
7512 {
7513 PyThreadState* __tstate = wxPyBeginAllowThreads();
7514 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7515
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj;
7530 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7531 size_t arg2 = (size_t) 0 ;
7532 size_t arg3 = (size_t) 1 ;
7533 bool result;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 PyObject * obj2 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 if (obj1) {
7545 {
7546 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7547 if (SWIG_arg_fail(2)) SWIG_fail;
7548 }
7549 }
7550 if (obj2) {
7551 {
7552 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7553 if (SWIG_arg_fail(3)) SWIG_fail;
7554 }
7555 }
7556 {
7557 PyThreadState* __tstate = wxPyBeginAllowThreads();
7558 result = (bool)(arg1)->InsertCols(arg2,arg3);
7559
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 {
7564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7565 }
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj;
7574 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7575 size_t arg2 = (size_t) 1 ;
7576 bool result;
7577 PyObject * obj0 = 0 ;
7578 PyObject * obj1 = 0 ;
7579 char *kwnames[] = {
7580 (char *) "self",(char *) "numCols", NULL
7581 };
7582
7583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7585 if (SWIG_arg_fail(1)) SWIG_fail;
7586 if (obj1) {
7587 {
7588 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7589 if (SWIG_arg_fail(2)) SWIG_fail;
7590 }
7591 }
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 result = (bool)(arg1)->AppendCols(arg2);
7595
7596 wxPyEndAllowThreads(__tstate);
7597 if (PyErr_Occurred()) SWIG_fail;
7598 }
7599 {
7600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7601 }
7602 return resultobj;
7603 fail:
7604 return NULL;
7605 }
7606
7607
7608 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7609 PyObject *resultobj;
7610 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7611 size_t arg2 = (size_t) 0 ;
7612 size_t arg3 = (size_t) 1 ;
7613 bool result;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 if (obj1) {
7625 {
7626 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7627 if (SWIG_arg_fail(2)) SWIG_fail;
7628 }
7629 }
7630 if (obj2) {
7631 {
7632 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7633 if (SWIG_arg_fail(3)) SWIG_fail;
7634 }
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj;
7654 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7655 int arg2 ;
7656 wxString result;
7657 PyObject * obj0 = 0 ;
7658 PyObject * obj1 = 0 ;
7659 char *kwnames[] = {
7660 (char *) "self",(char *) "row", NULL
7661 };
7662
7663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7665 if (SWIG_arg_fail(1)) SWIG_fail;
7666 {
7667 arg2 = (int)(SWIG_As_int(obj1));
7668 if (SWIG_arg_fail(2)) SWIG_fail;
7669 }
7670 {
7671 PyThreadState* __tstate = wxPyBeginAllowThreads();
7672 result = (arg1)->GetRowLabelValue(arg2);
7673
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 {
7678 #if wxUSE_UNICODE
7679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7680 #else
7681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7682 #endif
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7693 int arg2 ;
7694 wxString result;
7695 PyObject * obj0 = 0 ;
7696 PyObject * obj1 = 0 ;
7697 char *kwnames[] = {
7698 (char *) "self",(char *) "col", NULL
7699 };
7700
7701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7703 if (SWIG_arg_fail(1)) SWIG_fail;
7704 {
7705 arg2 = (int)(SWIG_As_int(obj1));
7706 if (SWIG_arg_fail(2)) SWIG_fail;
7707 }
7708 {
7709 PyThreadState* __tstate = wxPyBeginAllowThreads();
7710 result = (arg1)->GetColLabelValue(arg2);
7711
7712 wxPyEndAllowThreads(__tstate);
7713 if (PyErr_Occurred()) SWIG_fail;
7714 }
7715 {
7716 #if wxUSE_UNICODE
7717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7718 #else
7719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7720 #endif
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7731 int arg2 ;
7732 wxString *arg3 = 0 ;
7733 bool temp3 = false ;
7734 PyObject * obj0 = 0 ;
7735 PyObject * obj1 = 0 ;
7736 PyObject * obj2 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self",(char *) "row",(char *) "value", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 arg2 = (int)(SWIG_As_int(obj1));
7746 if (SWIG_arg_fail(2)) SWIG_fail;
7747 }
7748 {
7749 arg3 = wxString_in_helper(obj2);
7750 if (arg3 == NULL) SWIG_fail;
7751 temp3 = true;
7752 }
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7756
7757 wxPyEndAllowThreads(__tstate);
7758 if (PyErr_Occurred()) SWIG_fail;
7759 }
7760 Py_INCREF(Py_None); resultobj = Py_None;
7761 {
7762 if (temp3)
7763 delete arg3;
7764 }
7765 return resultobj;
7766 fail:
7767 {
7768 if (temp3)
7769 delete arg3;
7770 }
7771 return NULL;
7772 }
7773
7774
7775 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj;
7777 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7778 int arg2 ;
7779 wxString *arg3 = 0 ;
7780 bool temp3 = false ;
7781 PyObject * obj0 = 0 ;
7782 PyObject * obj1 = 0 ;
7783 PyObject * obj2 = 0 ;
7784 char *kwnames[] = {
7785 (char *) "self",(char *) "col",(char *) "value", NULL
7786 };
7787
7788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7790 if (SWIG_arg_fail(1)) SWIG_fail;
7791 {
7792 arg2 = (int)(SWIG_As_int(obj1));
7793 if (SWIG_arg_fail(2)) SWIG_fail;
7794 }
7795 {
7796 arg3 = wxString_in_helper(obj2);
7797 if (arg3 == NULL) SWIG_fail;
7798 temp3 = true;
7799 }
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 Py_INCREF(Py_None); resultobj = Py_None;
7808 {
7809 if (temp3)
7810 delete arg3;
7811 }
7812 return resultobj;
7813 fail:
7814 {
7815 if (temp3)
7816 delete arg3;
7817 }
7818 return NULL;
7819 }
7820
7821
7822 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj;
7824 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7825 bool result;
7826 PyObject * obj0 = 0 ;
7827 char *kwnames[] = {
7828 (char *) "self", NULL
7829 };
7830
7831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (bool)(arg1)->CanHaveAttributes();
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7853 int arg2 ;
7854 int arg3 ;
7855 wxGridCellAttr::wxAttrKind arg4 ;
7856 wxGridCellAttr *result;
7857 PyObject * obj0 = 0 ;
7858 PyObject * obj1 = 0 ;
7859 PyObject * obj2 = 0 ;
7860 PyObject * obj3 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 {
7869 arg2 = (int)(SWIG_As_int(obj1));
7870 if (SWIG_arg_fail(2)) SWIG_fail;
7871 }
7872 {
7873 arg3 = (int)(SWIG_As_int(obj2));
7874 if (SWIG_arg_fail(3)) SWIG_fail;
7875 }
7876 {
7877 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
7878 if (SWIG_arg_fail(4)) SWIG_fail;
7879 }
7880 {
7881 PyThreadState* __tstate = wxPyBeginAllowThreads();
7882 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
7883
7884 wxPyEndAllowThreads(__tstate);
7885 if (PyErr_Occurred()) SWIG_fail;
7886 }
7887 {
7888 resultobj = wxPyMake_wxGridCellAttr(result, 0);
7889 }
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj;
7898 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7899 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7900 int arg3 ;
7901 int arg4 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 PyObject * obj2 = 0 ;
7905 PyObject * obj3 = 0 ;
7906 char *kwnames[] = {
7907 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7908 };
7909
7910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7912 if (SWIG_arg_fail(1)) SWIG_fail;
7913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7914 if (SWIG_arg_fail(2)) SWIG_fail;
7915 {
7916 arg3 = (int)(SWIG_As_int(obj2));
7917 if (SWIG_arg_fail(3)) SWIG_fail;
7918 }
7919 {
7920 arg4 = (int)(SWIG_As_int(obj3));
7921 if (SWIG_arg_fail(4)) SWIG_fail;
7922 }
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 (arg1)->SetAttr(arg2,arg3,arg4);
7926
7927 wxPyEndAllowThreads(__tstate);
7928 if (PyErr_Occurred()) SWIG_fail;
7929 }
7930 Py_INCREF(Py_None); resultobj = Py_None;
7931 return resultobj;
7932 fail:
7933 return NULL;
7934 }
7935
7936
7937 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7938 PyObject *resultobj;
7939 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7940 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7941 int arg3 ;
7942 PyObject * obj0 = 0 ;
7943 PyObject * obj1 = 0 ;
7944 PyObject * obj2 = 0 ;
7945 char *kwnames[] = {
7946 (char *) "self",(char *) "attr",(char *) "row", NULL
7947 };
7948
7949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7951 if (SWIG_arg_fail(1)) SWIG_fail;
7952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7953 if (SWIG_arg_fail(2)) SWIG_fail;
7954 {
7955 arg3 = (int)(SWIG_As_int(obj2));
7956 if (SWIG_arg_fail(3)) SWIG_fail;
7957 }
7958 {
7959 PyThreadState* __tstate = wxPyBeginAllowThreads();
7960 (arg1)->SetRowAttr(arg2,arg3);
7961
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 Py_INCREF(Py_None); resultobj = Py_None;
7966 return resultobj;
7967 fail:
7968 return NULL;
7969 }
7970
7971
7972 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7973 PyObject *resultobj;
7974 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7975 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7976 int arg3 ;
7977 PyObject * obj0 = 0 ;
7978 PyObject * obj1 = 0 ;
7979 PyObject * obj2 = 0 ;
7980 char *kwnames[] = {
7981 (char *) "self",(char *) "attr",(char *) "col", NULL
7982 };
7983
7984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7986 if (SWIG_arg_fail(1)) SWIG_fail;
7987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7988 if (SWIG_arg_fail(2)) SWIG_fail;
7989 {
7990 arg3 = (int)(SWIG_As_int(obj2));
7991 if (SWIG_arg_fail(3)) SWIG_fail;
7992 }
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 (arg1)->SetColAttr(arg2,arg3);
7996
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 Py_INCREF(Py_None); resultobj = Py_None;
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
8008 PyObject *obj;
8009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8010 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
8011 Py_INCREF(obj);
8012 return Py_BuildValue((char *)"");
8013 }
8014 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj;
8016 wxPyGridTableBase *result;
8017 char *kwnames[] = {
8018 NULL
8019 };
8020
8021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8037 PyObject *resultobj;
8038 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8039 PyObject *arg2 = (PyObject *) 0 ;
8040 PyObject *arg3 = (PyObject *) 0 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 PyObject * obj2 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self",(char *) "self",(char *) "_class", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 arg2 = obj1;
8052 arg3 = obj2;
8053 {
8054 PyThreadState* __tstate = wxPyBeginAllowThreads();
8055 (arg1)->_setCallbackInfo(arg2,arg3);
8056
8057 wxPyEndAllowThreads(__tstate);
8058 if (PyErr_Occurred()) SWIG_fail;
8059 }
8060 Py_INCREF(Py_None); resultobj = Py_None;
8061 return resultobj;
8062 fail:
8063 return NULL;
8064 }
8065
8066
8067 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8068 PyObject *resultobj;
8069 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8070 PyObject * obj0 = 0 ;
8071 char *kwnames[] = {
8072 (char *) "self", NULL
8073 };
8074
8075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8077 if (SWIG_arg_fail(1)) SWIG_fail;
8078 {
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 wxPyGridTableBase_Destroy(arg1);
8081
8082 wxPyEndAllowThreads(__tstate);
8083 if (PyErr_Occurred()) SWIG_fail;
8084 }
8085 Py_INCREF(Py_None); resultobj = Py_None;
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 static PyObject *_wrap_PyGridTableBase_base_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8093 PyObject *resultobj;
8094 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8095 int arg2 ;
8096 int arg3 ;
8097 wxString result;
8098 PyObject * obj0 = 0 ;
8099 PyObject * obj1 = 0 ;
8100 PyObject * obj2 = 0 ;
8101 char *kwnames[] = {
8102 (char *) "self",(char *) "row",(char *) "col", NULL
8103 };
8104
8105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8107 if (SWIG_arg_fail(1)) SWIG_fail;
8108 {
8109 arg2 = (int)(SWIG_As_int(obj1));
8110 if (SWIG_arg_fail(2)) SWIG_fail;
8111 }
8112 {
8113 arg3 = (int)(SWIG_As_int(obj2));
8114 if (SWIG_arg_fail(3)) SWIG_fail;
8115 }
8116 {
8117 PyThreadState* __tstate = wxPyBeginAllowThreads();
8118 result = (arg1)->base_GetTypeName(arg2,arg3);
8119
8120 wxPyEndAllowThreads(__tstate);
8121 if (PyErr_Occurred()) SWIG_fail;
8122 }
8123 {
8124 #if wxUSE_UNICODE
8125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8126 #else
8127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8128 #endif
8129 }
8130 return resultobj;
8131 fail:
8132 return NULL;
8133 }
8134
8135
8136 static PyObject *_wrap_PyGridTableBase_base_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8137 PyObject *resultobj;
8138 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8139 int arg2 ;
8140 int arg3 ;
8141 wxString *arg4 = 0 ;
8142 bool result;
8143 bool temp4 = false ;
8144 PyObject * obj0 = 0 ;
8145 PyObject * obj1 = 0 ;
8146 PyObject * obj2 = 0 ;
8147 PyObject * obj3 = 0 ;
8148 char *kwnames[] = {
8149 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8150 };
8151
8152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8154 if (SWIG_arg_fail(1)) SWIG_fail;
8155 {
8156 arg2 = (int)(SWIG_As_int(obj1));
8157 if (SWIG_arg_fail(2)) SWIG_fail;
8158 }
8159 {
8160 arg3 = (int)(SWIG_As_int(obj2));
8161 if (SWIG_arg_fail(3)) SWIG_fail;
8162 }
8163 {
8164 arg4 = wxString_in_helper(obj3);
8165 if (arg4 == NULL) SWIG_fail;
8166 temp4 = true;
8167 }
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = (bool)(arg1)->base_CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8177 }
8178 {
8179 if (temp4)
8180 delete arg4;
8181 }
8182 return resultobj;
8183 fail:
8184 {
8185 if (temp4)
8186 delete arg4;
8187 }
8188 return NULL;
8189 }
8190
8191
8192 static PyObject *_wrap_PyGridTableBase_base_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8193 PyObject *resultobj;
8194 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8195 int arg2 ;
8196 int arg3 ;
8197 wxString *arg4 = 0 ;
8198 bool result;
8199 bool temp4 = false ;
8200 PyObject * obj0 = 0 ;
8201 PyObject * obj1 = 0 ;
8202 PyObject * obj2 = 0 ;
8203 PyObject * obj3 = 0 ;
8204 char *kwnames[] = {
8205 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8206 };
8207
8208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(1)) SWIG_fail;
8211 {
8212 arg2 = (int)(SWIG_As_int(obj1));
8213 if (SWIG_arg_fail(2)) SWIG_fail;
8214 }
8215 {
8216 arg3 = (int)(SWIG_As_int(obj2));
8217 if (SWIG_arg_fail(3)) SWIG_fail;
8218 }
8219 {
8220 arg4 = wxString_in_helper(obj3);
8221 if (arg4 == NULL) SWIG_fail;
8222 temp4 = true;
8223 }
8224 {
8225 PyThreadState* __tstate = wxPyBeginAllowThreads();
8226 result = (bool)(arg1)->base_CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8227
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 {
8232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8233 }
8234 {
8235 if (temp4)
8236 delete arg4;
8237 }
8238 return resultobj;
8239 fail:
8240 {
8241 if (temp4)
8242 delete arg4;
8243 }
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_PyGridTableBase_base_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8251 PyObject * obj0 = 0 ;
8252 char *kwnames[] = {
8253 (char *) "self", NULL
8254 };
8255
8256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_Clear",kwnames,&obj0)) goto fail;
8257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8258 if (SWIG_arg_fail(1)) SWIG_fail;
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->base_Clear();
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 Py_INCREF(Py_None); resultobj = Py_None;
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 static PyObject *_wrap_PyGridTableBase_base_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8274 PyObject *resultobj;
8275 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8276 size_t arg2 = (size_t) 0 ;
8277 size_t arg3 = (size_t) 1 ;
8278 bool result;
8279 PyObject * obj0 = 0 ;
8280 PyObject * obj1 = 0 ;
8281 PyObject * obj2 = 0 ;
8282 char *kwnames[] = {
8283 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8284 };
8285
8286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8288 if (SWIG_arg_fail(1)) SWIG_fail;
8289 if (obj1) {
8290 {
8291 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8292 if (SWIG_arg_fail(2)) SWIG_fail;
8293 }
8294 }
8295 if (obj2) {
8296 {
8297 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8298 if (SWIG_arg_fail(3)) SWIG_fail;
8299 }
8300 }
8301 {
8302 PyThreadState* __tstate = wxPyBeginAllowThreads();
8303 result = (bool)(arg1)->base_InsertRows(arg2,arg3);
8304
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 {
8309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8310 }
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 static PyObject *_wrap_PyGridTableBase_base_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj;
8319 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8320 size_t arg2 = (size_t) 1 ;
8321 bool result;
8322 PyObject * obj0 = 0 ;
8323 PyObject * obj1 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self",(char *) "numRows", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 if (obj1) {
8332 {
8333 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8334 if (SWIG_arg_fail(2)) SWIG_fail;
8335 }
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (bool)(arg1)->base_AppendRows(arg2);
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8346 }
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 static PyObject *_wrap_PyGridTableBase_base_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj;
8355 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8356 size_t arg2 = (size_t) 0 ;
8357 size_t arg3 = (size_t) 1 ;
8358 bool result;
8359 PyObject * obj0 = 0 ;
8360 PyObject * obj1 = 0 ;
8361 PyObject * obj2 = 0 ;
8362 char *kwnames[] = {
8363 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8364 };
8365
8366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8368 if (SWIG_arg_fail(1)) SWIG_fail;
8369 if (obj1) {
8370 {
8371 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8372 if (SWIG_arg_fail(2)) SWIG_fail;
8373 }
8374 }
8375 if (obj2) {
8376 {
8377 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8378 if (SWIG_arg_fail(3)) SWIG_fail;
8379 }
8380 }
8381 {
8382 PyThreadState* __tstate = wxPyBeginAllowThreads();
8383 result = (bool)(arg1)->base_DeleteRows(arg2,arg3);
8384
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 {
8389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8390 }
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 static PyObject *_wrap_PyGridTableBase_base_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj;
8399 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8400 size_t arg2 = (size_t) 0 ;
8401 size_t arg3 = (size_t) 1 ;
8402 bool result;
8403 PyObject * obj0 = 0 ;
8404 PyObject * obj1 = 0 ;
8405 PyObject * obj2 = 0 ;
8406 char *kwnames[] = {
8407 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8408 };
8409
8410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8412 if (SWIG_arg_fail(1)) SWIG_fail;
8413 if (obj1) {
8414 {
8415 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8416 if (SWIG_arg_fail(2)) SWIG_fail;
8417 }
8418 }
8419 if (obj2) {
8420 {
8421 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8422 if (SWIG_arg_fail(3)) SWIG_fail;
8423 }
8424 }
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 result = (bool)(arg1)->base_InsertCols(arg2,arg3);
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 {
8433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8434 }
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 static PyObject *_wrap_PyGridTableBase_base_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8442 PyObject *resultobj;
8443 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8444 size_t arg2 = (size_t) 1 ;
8445 bool result;
8446 PyObject * obj0 = 0 ;
8447 PyObject * obj1 = 0 ;
8448 char *kwnames[] = {
8449 (char *) "self",(char *) "numCols", NULL
8450 };
8451
8452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8454 if (SWIG_arg_fail(1)) SWIG_fail;
8455 if (obj1) {
8456 {
8457 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8458 if (SWIG_arg_fail(2)) SWIG_fail;
8459 }
8460 }
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (bool)(arg1)->base_AppendCols(arg2);
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 {
8469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8470 }
8471 return resultobj;
8472 fail:
8473 return NULL;
8474 }
8475
8476
8477 static PyObject *_wrap_PyGridTableBase_base_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8478 PyObject *resultobj;
8479 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8480 size_t arg2 = (size_t) 0 ;
8481 size_t arg3 = (size_t) 1 ;
8482 bool result;
8483 PyObject * obj0 = 0 ;
8484 PyObject * obj1 = 0 ;
8485 PyObject * obj2 = 0 ;
8486 char *kwnames[] = {
8487 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8488 };
8489
8490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8492 if (SWIG_arg_fail(1)) SWIG_fail;
8493 if (obj1) {
8494 {
8495 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8496 if (SWIG_arg_fail(2)) SWIG_fail;
8497 }
8498 }
8499 if (obj2) {
8500 {
8501 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8502 if (SWIG_arg_fail(3)) SWIG_fail;
8503 }
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (bool)(arg1)->base_DeleteCols(arg2,arg3);
8508
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 {
8513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8514 }
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 static PyObject *_wrap_PyGridTableBase_base_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj;
8523 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8524 int arg2 ;
8525 wxString result;
8526 PyObject * obj0 = 0 ;
8527 PyObject * obj1 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "self",(char *) "row", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 {
8536 arg2 = (int)(SWIG_As_int(obj1));
8537 if (SWIG_arg_fail(2)) SWIG_fail;
8538 }
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 result = (arg1)->base_GetRowLabelValue(arg2);
8542
8543 wxPyEndAllowThreads(__tstate);
8544 if (PyErr_Occurred()) SWIG_fail;
8545 }
8546 {
8547 #if wxUSE_UNICODE
8548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8549 #else
8550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8551 #endif
8552 }
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 static PyObject *_wrap_PyGridTableBase_base_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj;
8561 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8562 int arg2 ;
8563 wxString result;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char *kwnames[] = {
8567 (char *) "self",(char *) "col", NULL
8568 };
8569
8570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8572 if (SWIG_arg_fail(1)) SWIG_fail;
8573 {
8574 arg2 = (int)(SWIG_As_int(obj1));
8575 if (SWIG_arg_fail(2)) SWIG_fail;
8576 }
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->base_GetColLabelValue(arg2);
8580
8581 wxPyEndAllowThreads(__tstate);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 {
8585 #if wxUSE_UNICODE
8586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8587 #else
8588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8589 #endif
8590 }
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 static PyObject *_wrap_PyGridTableBase_base_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj;
8599 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8600 int arg2 ;
8601 wxString *arg3 = 0 ;
8602 bool temp3 = false ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 PyObject * obj2 = 0 ;
8606 char *kwnames[] = {
8607 (char *) "self",(char *) "row",(char *) "value", NULL
8608 };
8609
8610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8612 if (SWIG_arg_fail(1)) SWIG_fail;
8613 {
8614 arg2 = (int)(SWIG_As_int(obj1));
8615 if (SWIG_arg_fail(2)) SWIG_fail;
8616 }
8617 {
8618 arg3 = wxString_in_helper(obj2);
8619 if (arg3 == NULL) SWIG_fail;
8620 temp3 = true;
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 (arg1)->base_SetRowLabelValue(arg2,(wxString const &)*arg3);
8625
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 Py_INCREF(Py_None); resultobj = Py_None;
8630 {
8631 if (temp3)
8632 delete arg3;
8633 }
8634 return resultobj;
8635 fail:
8636 {
8637 if (temp3)
8638 delete arg3;
8639 }
8640 return NULL;
8641 }
8642
8643
8644 static PyObject *_wrap_PyGridTableBase_base_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8645 PyObject *resultobj;
8646 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8647 int arg2 ;
8648 wxString *arg3 = 0 ;
8649 bool temp3 = false ;
8650 PyObject * obj0 = 0 ;
8651 PyObject * obj1 = 0 ;
8652 PyObject * obj2 = 0 ;
8653 char *kwnames[] = {
8654 (char *) "self",(char *) "col",(char *) "value", NULL
8655 };
8656
8657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8659 if (SWIG_arg_fail(1)) SWIG_fail;
8660 {
8661 arg2 = (int)(SWIG_As_int(obj1));
8662 if (SWIG_arg_fail(2)) SWIG_fail;
8663 }
8664 {
8665 arg3 = wxString_in_helper(obj2);
8666 if (arg3 == NULL) SWIG_fail;
8667 temp3 = true;
8668 }
8669 {
8670 PyThreadState* __tstate = wxPyBeginAllowThreads();
8671 (arg1)->base_SetColLabelValue(arg2,(wxString const &)*arg3);
8672
8673 wxPyEndAllowThreads(__tstate);
8674 if (PyErr_Occurred()) SWIG_fail;
8675 }
8676 Py_INCREF(Py_None); resultobj = Py_None;
8677 {
8678 if (temp3)
8679 delete arg3;
8680 }
8681 return resultobj;
8682 fail:
8683 {
8684 if (temp3)
8685 delete arg3;
8686 }
8687 return NULL;
8688 }
8689
8690
8691 static PyObject *_wrap_PyGridTableBase_base_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8692 PyObject *resultobj;
8693 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8694 bool result;
8695 PyObject * obj0 = 0 ;
8696 char *kwnames[] = {
8697 (char *) "self", NULL
8698 };
8699
8700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_CanHaveAttributes",kwnames,&obj0)) goto fail;
8701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8702 if (SWIG_arg_fail(1)) SWIG_fail;
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 result = (bool)(arg1)->base_CanHaveAttributes();
8706
8707 wxPyEndAllowThreads(__tstate);
8708 if (PyErr_Occurred()) SWIG_fail;
8709 }
8710 {
8711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8712 }
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 static PyObject *_wrap_PyGridTableBase_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj;
8721 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8722 int arg2 ;
8723 int arg3 ;
8724 wxGridCellAttr::wxAttrKind arg4 ;
8725 wxGridCellAttr *result;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 PyObject * obj2 = 0 ;
8729 PyObject * obj3 = 0 ;
8730 char *kwnames[] = {
8731 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8732 };
8733
8734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8736 if (SWIG_arg_fail(1)) SWIG_fail;
8737 {
8738 arg2 = (int)(SWIG_As_int(obj1));
8739 if (SWIG_arg_fail(2)) SWIG_fail;
8740 }
8741 {
8742 arg3 = (int)(SWIG_As_int(obj2));
8743 if (SWIG_arg_fail(3)) SWIG_fail;
8744 }
8745 {
8746 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
8747 if (SWIG_arg_fail(4)) SWIG_fail;
8748 }
8749 {
8750 PyThreadState* __tstate = wxPyBeginAllowThreads();
8751 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
8752
8753 wxPyEndAllowThreads(__tstate);
8754 if (PyErr_Occurred()) SWIG_fail;
8755 }
8756 {
8757 resultobj = wxPyMake_wxGridCellAttr(result, 0);
8758 }
8759 return resultobj;
8760 fail:
8761 return NULL;
8762 }
8763
8764
8765 static PyObject *_wrap_PyGridTableBase_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8766 PyObject *resultobj;
8767 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8768 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8769 int arg3 ;
8770 int arg4 ;
8771 PyObject * obj0 = 0 ;
8772 PyObject * obj1 = 0 ;
8773 PyObject * obj2 = 0 ;
8774 PyObject * obj3 = 0 ;
8775 char *kwnames[] = {
8776 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8781 if (SWIG_arg_fail(1)) SWIG_fail;
8782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8783 if (SWIG_arg_fail(2)) SWIG_fail;
8784 {
8785 arg3 = (int)(SWIG_As_int(obj2));
8786 if (SWIG_arg_fail(3)) SWIG_fail;
8787 }
8788 {
8789 arg4 = (int)(SWIG_As_int(obj3));
8790 if (SWIG_arg_fail(4)) SWIG_fail;
8791 }
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 (arg1)->base_SetAttr(arg2,arg3,arg4);
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 Py_INCREF(Py_None); resultobj = Py_None;
8800 return resultobj;
8801 fail:
8802 return NULL;
8803 }
8804
8805
8806 static PyObject *_wrap_PyGridTableBase_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8807 PyObject *resultobj;
8808 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8809 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8810 int arg3 ;
8811 PyObject * obj0 = 0 ;
8812 PyObject * obj1 = 0 ;
8813 PyObject * obj2 = 0 ;
8814 char *kwnames[] = {
8815 (char *) "self",(char *) "attr",(char *) "row", NULL
8816 };
8817
8818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8820 if (SWIG_arg_fail(1)) SWIG_fail;
8821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8822 if (SWIG_arg_fail(2)) SWIG_fail;
8823 {
8824 arg3 = (int)(SWIG_As_int(obj2));
8825 if (SWIG_arg_fail(3)) SWIG_fail;
8826 }
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 (arg1)->base_SetRowAttr(arg2,arg3);
8830
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 Py_INCREF(Py_None); resultobj = Py_None;
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 static PyObject *_wrap_PyGridTableBase_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj;
8843 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8844 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8845 int arg3 ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 PyObject * obj2 = 0 ;
8849 char *kwnames[] = {
8850 (char *) "self",(char *) "attr",(char *) "col", NULL
8851 };
8852
8853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8855 if (SWIG_arg_fail(1)) SWIG_fail;
8856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8857 if (SWIG_arg_fail(2)) SWIG_fail;
8858 {
8859 arg3 = (int)(SWIG_As_int(obj2));
8860 if (SWIG_arg_fail(3)) SWIG_fail;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 (arg1)->base_SetColAttr(arg2,arg3);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 Py_INCREF(Py_None); resultobj = Py_None;
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
8877 PyObject *obj;
8878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8879 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
8880 Py_INCREF(obj);
8881 return Py_BuildValue((char *)"");
8882 }
8883 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
8884 PyObject *resultobj;
8885 int arg1 = (int) 0 ;
8886 int arg2 = (int) 0 ;
8887 wxGridStringTable *result;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "numRows",(char *) "numCols", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
8895 if (obj0) {
8896 {
8897 arg1 = (int)(SWIG_As_int(obj0));
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 }
8900 }
8901 if (obj1) {
8902 {
8903 arg2 = (int)(SWIG_As_int(obj1));
8904 if (SWIG_arg_fail(2)) SWIG_fail;
8905 }
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
8910
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
8922 PyObject *obj;
8923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8924 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
8925 Py_INCREF(obj);
8926 return Py_BuildValue((char *)"");
8927 }
8928 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8931 int arg2 ;
8932 int arg3 = (int) -1 ;
8933 int arg4 = (int) -1 ;
8934 wxGridTableMessage *result;
8935 PyObject * obj0 = 0 ;
8936 PyObject * obj1 = 0 ;
8937 PyObject * obj2 = 0 ;
8938 PyObject * obj3 = 0 ;
8939 char *kwnames[] = {
8940 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
8941 };
8942
8943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8945 if (SWIG_arg_fail(1)) SWIG_fail;
8946 {
8947 arg2 = (int)(SWIG_As_int(obj1));
8948 if (SWIG_arg_fail(2)) SWIG_fail;
8949 }
8950 if (obj2) {
8951 {
8952 arg3 = (int)(SWIG_As_int(obj2));
8953 if (SWIG_arg_fail(3)) SWIG_fail;
8954 }
8955 }
8956 if (obj3) {
8957 {
8958 arg4 = (int)(SWIG_As_int(obj3));
8959 if (SWIG_arg_fail(4)) SWIG_fail;
8960 }
8961 }
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
8965
8966 wxPyEndAllowThreads(__tstate);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
8970 return resultobj;
8971 fail:
8972 return NULL;
8973 }
8974
8975
8976 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj;
8978 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8979 PyObject * obj0 = 0 ;
8980 char *kwnames[] = {
8981 (char *) "self", NULL
8982 };
8983
8984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
8985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8986 if (SWIG_arg_fail(1)) SWIG_fail;
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 delete arg1;
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 Py_INCREF(Py_None); resultobj = Py_None;
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj;
9003 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9004 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9005 PyObject * obj0 = 0 ;
9006 PyObject * obj1 = 0 ;
9007 char *kwnames[] = {
9008 (char *) "self",(char *) "table", NULL
9009 };
9010
9011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
9012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9013 if (SWIG_arg_fail(1)) SWIG_fail;
9014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9015 if (SWIG_arg_fail(2)) SWIG_fail;
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 (arg1)->SetTableObject(arg2);
9019
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 Py_INCREF(Py_None); resultobj = Py_None;
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj;
9032 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9033 wxGridTableBase *result;
9034 PyObject * obj0 = 0 ;
9035 char *kwnames[] = {
9036 (char *) "self", NULL
9037 };
9038
9039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9041 if (SWIG_arg_fail(1)) SWIG_fail;
9042 {
9043 PyThreadState* __tstate = wxPyBeginAllowThreads();
9044 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9045
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 {
9050 resultobj = wxPyMake_wxGridTableBase(result, 0);
9051 }
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj;
9060 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9061 int arg2 ;
9062 PyObject * obj0 = 0 ;
9063 PyObject * obj1 = 0 ;
9064 char *kwnames[] = {
9065 (char *) "self",(char *) "id", NULL
9066 };
9067
9068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9070 if (SWIG_arg_fail(1)) SWIG_fail;
9071 {
9072 arg2 = (int)(SWIG_As_int(obj1));
9073 if (SWIG_arg_fail(2)) SWIG_fail;
9074 }
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 (arg1)->SetId(arg2);
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 Py_INCREF(Py_None); resultobj = Py_None;
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9092 int result;
9093 PyObject * obj0 = 0 ;
9094 char *kwnames[] = {
9095 (char *) "self", NULL
9096 };
9097
9098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9100 if (SWIG_arg_fail(1)) SWIG_fail;
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (int)(arg1)->GetId();
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 {
9109 resultobj = SWIG_From_int((int)(result));
9110 }
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj;
9119 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9120 int arg2 ;
9121 PyObject * obj0 = 0 ;
9122 PyObject * obj1 = 0 ;
9123 char *kwnames[] = {
9124 (char *) "self",(char *) "comInt1", NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9129 if (SWIG_arg_fail(1)) SWIG_fail;
9130 {
9131 arg2 = (int)(SWIG_As_int(obj1));
9132 if (SWIG_arg_fail(2)) SWIG_fail;
9133 }
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 (arg1)->SetCommandInt(arg2);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj;
9150 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9151 int result;
9152 PyObject * obj0 = 0 ;
9153 char *kwnames[] = {
9154 (char *) "self", NULL
9155 };
9156
9157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9159 if (SWIG_arg_fail(1)) SWIG_fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (int)(arg1)->GetCommandInt();
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 {
9168 resultobj = SWIG_From_int((int)(result));
9169 }
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj;
9178 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9179 int arg2 ;
9180 PyObject * obj0 = 0 ;
9181 PyObject * obj1 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "self",(char *) "comInt2", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9188 if (SWIG_arg_fail(1)) SWIG_fail;
9189 {
9190 arg2 = (int)(SWIG_As_int(obj1));
9191 if (SWIG_arg_fail(2)) SWIG_fail;
9192 }
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 (arg1)->SetCommandInt2(arg2);
9196
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 Py_INCREF(Py_None); resultobj = Py_None;
9201 return resultobj;
9202 fail:
9203 return NULL;
9204 }
9205
9206
9207 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9208 PyObject *resultobj;
9209 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9210 int result;
9211 PyObject * obj0 = 0 ;
9212 char *kwnames[] = {
9213 (char *) "self", NULL
9214 };
9215
9216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9218 if (SWIG_arg_fail(1)) SWIG_fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (int)(arg1)->GetCommandInt2();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 {
9227 resultobj = SWIG_From_int((int)(result));
9228 }
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9236 PyObject *obj;
9237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9238 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9239 Py_INCREF(obj);
9240 return Py_BuildValue((char *)"");
9241 }
9242 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj;
9244 int arg1 = (int) -1 ;
9245 int arg2 = (int) -1 ;
9246 wxGridCellCoords *result;
9247 PyObject * obj0 = 0 ;
9248 PyObject * obj1 = 0 ;
9249 char *kwnames[] = {
9250 (char *) "r",(char *) "c", NULL
9251 };
9252
9253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9254 if (obj0) {
9255 {
9256 arg1 = (int)(SWIG_As_int(obj0));
9257 if (SWIG_arg_fail(1)) SWIG_fail;
9258 }
9259 }
9260 if (obj1) {
9261 {
9262 arg2 = (int)(SWIG_As_int(obj1));
9263 if (SWIG_arg_fail(2)) SWIG_fail;
9264 }
9265 }
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9283 PyObject * obj0 = 0 ;
9284 char *kwnames[] = {
9285 (char *) "self", NULL
9286 };
9287
9288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9290 if (SWIG_arg_fail(1)) SWIG_fail;
9291 {
9292 PyThreadState* __tstate = wxPyBeginAllowThreads();
9293 delete arg1;
9294
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 Py_INCREF(Py_None); resultobj = Py_None;
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9306 PyObject *resultobj;
9307 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9308 int result;
9309 PyObject * obj0 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "self", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9316 if (SWIG_arg_fail(1)) SWIG_fail;
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 {
9325 resultobj = SWIG_From_int((int)(result));
9326 }
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9336 int arg2 ;
9337 PyObject * obj0 = 0 ;
9338 PyObject * obj1 = 0 ;
9339 char *kwnames[] = {
9340 (char *) "self",(char *) "n", NULL
9341 };
9342
9343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9345 if (SWIG_arg_fail(1)) SWIG_fail;
9346 {
9347 arg2 = (int)(SWIG_As_int(obj1));
9348 if (SWIG_arg_fail(2)) SWIG_fail;
9349 }
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 (arg1)->SetRow(arg2);
9353
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 Py_INCREF(Py_None); resultobj = Py_None;
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj;
9366 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9367 int result;
9368 PyObject * obj0 = 0 ;
9369 char *kwnames[] = {
9370 (char *) "self", NULL
9371 };
9372
9373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9375 if (SWIG_arg_fail(1)) SWIG_fail;
9376 {
9377 PyThreadState* __tstate = wxPyBeginAllowThreads();
9378 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9379
9380 wxPyEndAllowThreads(__tstate);
9381 if (PyErr_Occurred()) SWIG_fail;
9382 }
9383 {
9384 resultobj = SWIG_From_int((int)(result));
9385 }
9386 return resultobj;
9387 fail:
9388 return NULL;
9389 }
9390
9391
9392 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9393 PyObject *resultobj;
9394 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9395 int arg2 ;
9396 PyObject * obj0 = 0 ;
9397 PyObject * obj1 = 0 ;
9398 char *kwnames[] = {
9399 (char *) "self",(char *) "n", NULL
9400 };
9401
9402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9404 if (SWIG_arg_fail(1)) SWIG_fail;
9405 {
9406 arg2 = (int)(SWIG_As_int(obj1));
9407 if (SWIG_arg_fail(2)) SWIG_fail;
9408 }
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 (arg1)->SetCol(arg2);
9412
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 Py_INCREF(Py_None); resultobj = Py_None;
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj;
9425 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9426 int arg2 ;
9427 int arg3 ;
9428 PyObject * obj0 = 0 ;
9429 PyObject * obj1 = 0 ;
9430 PyObject * obj2 = 0 ;
9431 char *kwnames[] = {
9432 (char *) "self",(char *) "row",(char *) "col", NULL
9433 };
9434
9435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9437 if (SWIG_arg_fail(1)) SWIG_fail;
9438 {
9439 arg2 = (int)(SWIG_As_int(obj1));
9440 if (SWIG_arg_fail(2)) SWIG_fail;
9441 }
9442 {
9443 arg3 = (int)(SWIG_As_int(obj2));
9444 if (SWIG_arg_fail(3)) SWIG_fail;
9445 }
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 (arg1)->Set(arg2,arg3);
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 Py_INCREF(Py_None); resultobj = Py_None;
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9463 wxGridCellCoords *arg2 = 0 ;
9464 bool result;
9465 wxGridCellCoords temp2 ;
9466 PyObject * obj0 = 0 ;
9467 PyObject * obj1 = 0 ;
9468 char *kwnames[] = {
9469 (char *) "self",(char *) "other", NULL
9470 };
9471
9472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) goto fail;
9473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9474 if (SWIG_arg_fail(1)) SWIG_fail;
9475 {
9476 arg2 = &temp2;
9477 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9478 }
9479 {
9480 PyThreadState* __tstate = wxPyBeginAllowThreads();
9481 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9482
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 {
9487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9488 }
9489 return resultobj;
9490 fail:
9491 return NULL;
9492 }
9493
9494
9495 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9498 wxGridCellCoords *arg2 = 0 ;
9499 bool result;
9500 wxGridCellCoords temp2 ;
9501 PyObject * obj0 = 0 ;
9502 PyObject * obj1 = 0 ;
9503 char *kwnames[] = {
9504 (char *) "self",(char *) "other", NULL
9505 };
9506
9507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9509 if (SWIG_arg_fail(1)) SWIG_fail;
9510 {
9511 arg2 = &temp2;
9512 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9513 }
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 {
9522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9523 }
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj;
9532 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9533 PyObject *result;
9534 PyObject * obj0 = 0 ;
9535 char *kwnames[] = {
9536 (char *) "self", NULL
9537 };
9538
9539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9541 if (SWIG_arg_fail(1)) SWIG_fail;
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 result = (PyObject *)wxGridCellCoords_Get(arg1);
9545
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = result;
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9557 PyObject *obj;
9558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9559 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9560 Py_INCREF(obj);
9561 return Py_BuildValue((char *)"");
9562 }
9563 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj;
9565 wxWindow *arg1 = (wxWindow *) 0 ;
9566 int arg2 = (int) -1 ;
9567 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9568 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9569 wxSize const &arg4_defvalue = wxDefaultSize ;
9570 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9571 long arg5 = (long) wxWANTS_CHARS ;
9572 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9573 wxString *arg6 = (wxString *) &arg6_defvalue ;
9574 wxGrid *result;
9575 wxPoint temp3 ;
9576 wxSize temp4 ;
9577 bool temp6 = false ;
9578 PyObject * obj0 = 0 ;
9579 PyObject * obj1 = 0 ;
9580 PyObject * obj2 = 0 ;
9581 PyObject * obj3 = 0 ;
9582 PyObject * obj4 = 0 ;
9583 PyObject * obj5 = 0 ;
9584 char *kwnames[] = {
9585 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9586 };
9587
9588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9590 if (SWIG_arg_fail(1)) SWIG_fail;
9591 if (obj1) {
9592 {
9593 arg2 = (int)(SWIG_As_int(obj1));
9594 if (SWIG_arg_fail(2)) SWIG_fail;
9595 }
9596 }
9597 if (obj2) {
9598 {
9599 arg3 = &temp3;
9600 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9601 }
9602 }
9603 if (obj3) {
9604 {
9605 arg4 = &temp4;
9606 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9607 }
9608 }
9609 if (obj4) {
9610 {
9611 arg5 = (long)(SWIG_As_long(obj4));
9612 if (SWIG_arg_fail(5)) SWIG_fail;
9613 }
9614 }
9615 if (obj5) {
9616 {
9617 arg6 = wxString_in_helper(obj5);
9618 if (arg6 == NULL) SWIG_fail;
9619 temp6 = true;
9620 }
9621 }
9622 {
9623 if (!wxPyCheckForApp()) SWIG_fail;
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9631 {
9632 if (temp6)
9633 delete arg6;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp6)
9639 delete arg6;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxGrid *result;
9648 char *kwnames[] = {
9649 NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9653 {
9654 if (!wxPyCheckForApp()) SWIG_fail;
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (wxGrid *)new wxGrid();
9657
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9669 PyObject *resultobj;
9670 wxGrid *arg1 = (wxGrid *) 0 ;
9671 wxWindow *arg2 = (wxWindow *) 0 ;
9672 int arg3 = (int) -1 ;
9673 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9674 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9675 wxSize const &arg5_defvalue = wxDefaultSize ;
9676 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9677 long arg6 = (long) wxWANTS_CHARS ;
9678 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9679 wxString *arg7 = (wxString *) &arg7_defvalue ;
9680 bool result;
9681 wxPoint temp4 ;
9682 wxSize temp5 ;
9683 bool temp7 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 PyObject * obj2 = 0 ;
9687 PyObject * obj3 = 0 ;
9688 PyObject * obj4 = 0 ;
9689 PyObject * obj5 = 0 ;
9690 PyObject * obj6 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(1)) SWIG_fail;
9698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9699 if (SWIG_arg_fail(2)) SWIG_fail;
9700 if (obj2) {
9701 {
9702 arg3 = (int)(SWIG_As_int(obj2));
9703 if (SWIG_arg_fail(3)) SWIG_fail;
9704 }
9705 }
9706 if (obj3) {
9707 {
9708 arg4 = &temp4;
9709 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9710 }
9711 }
9712 if (obj4) {
9713 {
9714 arg5 = &temp5;
9715 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9716 }
9717 }
9718 if (obj5) {
9719 {
9720 arg6 = (long)(SWIG_As_long(obj5));
9721 if (SWIG_arg_fail(6)) SWIG_fail;
9722 }
9723 }
9724 if (obj6) {
9725 {
9726 arg7 = wxString_in_helper(obj6);
9727 if (arg7 == NULL) SWIG_fail;
9728 temp7 = true;
9729 }
9730 }
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9734
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 {
9739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9740 }
9741 {
9742 if (temp7)
9743 delete arg7;
9744 }
9745 return resultobj;
9746 fail:
9747 {
9748 if (temp7)
9749 delete arg7;
9750 }
9751 return NULL;
9752 }
9753
9754
9755 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj;
9757 wxGrid *arg1 = (wxGrid *) 0 ;
9758 int arg2 ;
9759 int arg3 ;
9760 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9761 bool result;
9762 PyObject * obj0 = 0 ;
9763 PyObject * obj1 = 0 ;
9764 PyObject * obj2 = 0 ;
9765 PyObject * obj3 = 0 ;
9766 char *kwnames[] = {
9767 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9768 };
9769
9770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9772 if (SWIG_arg_fail(1)) SWIG_fail;
9773 {
9774 arg2 = (int)(SWIG_As_int(obj1));
9775 if (SWIG_arg_fail(2)) SWIG_fail;
9776 }
9777 {
9778 arg3 = (int)(SWIG_As_int(obj2));
9779 if (SWIG_arg_fail(3)) SWIG_fail;
9780 }
9781 if (obj3) {
9782 {
9783 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9784 if (SWIG_arg_fail(4)) SWIG_fail;
9785 }
9786 }
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9790
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 {
9795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9796 }
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj;
9805 wxGrid *arg1 = (wxGrid *) 0 ;
9806 WXGRIDSELECTIONMODES arg2 ;
9807 PyObject * obj0 = 0 ;
9808 PyObject * obj1 = 0 ;
9809 char *kwnames[] = {
9810 (char *) "self",(char *) "selmode", NULL
9811 };
9812
9813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
9814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(1)) SWIG_fail;
9816 {
9817 arg2 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj1));
9818 if (SWIG_arg_fail(2)) SWIG_fail;
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 (arg1)->SetSelectionMode(arg2);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 Py_INCREF(Py_None); resultobj = Py_None;
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
9834 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj;
9836 wxGrid *arg1 = (wxGrid *) 0 ;
9837 WXGRIDSELECTIONMODES result;
9838 PyObject * obj0 = 0 ;
9839 char *kwnames[] = {
9840 (char *) "self", NULL
9841 };
9842
9843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
9844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9845 if (SWIG_arg_fail(1)) SWIG_fail;
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
9849
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 resultobj = SWIG_From_int((int)(result));
9855 }
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj;
9864 wxGrid *arg1 = (wxGrid *) 0 ;
9865 int result;
9866 PyObject * obj0 = 0 ;
9867 char *kwnames[] = {
9868 (char *) "self", NULL
9869 };
9870
9871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
9872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9873 if (SWIG_arg_fail(1)) SWIG_fail;
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 result = (int)(arg1)->GetNumberRows();
9877
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 {
9882 resultobj = SWIG_From_int((int)(result));
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxGrid *arg1 = (wxGrid *) 0 ;
9893 int result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "self", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (int)(arg1)->GetNumberCols();
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 {
9910 resultobj = SWIG_From_int((int)(result));
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxGrid *arg1 = (wxGrid *) 0 ;
9921 wxGridTableMessage *arg2 = 0 ;
9922 bool result;
9923 PyObject * obj0 = 0 ;
9924 PyObject * obj1 = 0 ;
9925 char *kwnames[] = {
9926 (char *) "self","arg2", NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
9930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(1)) SWIG_fail;
9932 {
9933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9934 if (SWIG_arg_fail(2)) SWIG_fail;
9935 if (arg2 == NULL) {
9936 SWIG_null_ref("wxGridTableMessage");
9937 }
9938 if (SWIG_arg_fail(2)) SWIG_fail;
9939 }
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (bool)(arg1)->ProcessTableMessage(*arg2);
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 {
9948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9949 }
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9957 PyObject *resultobj;
9958 wxGrid *arg1 = (wxGrid *) 0 ;
9959 wxGridTableBase *result;
9960 PyObject * obj0 = 0 ;
9961 char *kwnames[] = {
9962 (char *) "self", NULL
9963 };
9964
9965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
9966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = wxPyMake_wxGridTableBase(result, 0);
9977 }
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxGrid *arg1 = (wxGrid *) 0 ;
9987 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9988 bool arg3 = (bool) false ;
9989 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9990 bool result;
9991 PyObject * obj0 = 0 ;
9992 PyObject * obj1 = 0 ;
9993 PyObject * obj2 = 0 ;
9994 PyObject * obj3 = 0 ;
9995 char *kwnames[] = {
9996 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
9997 };
9998
9999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10001 if (SWIG_arg_fail(1)) SWIG_fail;
10002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
10003 if (SWIG_arg_fail(2)) SWIG_fail;
10004 if (obj2) {
10005 {
10006 arg3 = (bool)(SWIG_As_bool(obj2));
10007 if (SWIG_arg_fail(3)) SWIG_fail;
10008 }
10009 }
10010 if (obj3) {
10011 {
10012 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
10013 if (SWIG_arg_fail(4)) SWIG_fail;
10014 }
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 {
10024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10025 }
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10033 PyObject *resultobj;
10034 wxGrid *arg1 = (wxGrid *) 0 ;
10035 PyObject * obj0 = 0 ;
10036 char *kwnames[] = {
10037 (char *) "self", NULL
10038 };
10039
10040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10042 if (SWIG_arg_fail(1)) SWIG_fail;
10043 {
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 (arg1)->ClearGrid();
10046
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 Py_INCREF(Py_None); resultobj = Py_None;
10051 return resultobj;
10052 fail:
10053 return NULL;
10054 }
10055
10056
10057 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10058 PyObject *resultobj;
10059 wxGrid *arg1 = (wxGrid *) 0 ;
10060 int arg2 = (int) 0 ;
10061 int arg3 = (int) 1 ;
10062 bool arg4 = (bool) true ;
10063 bool result;
10064 PyObject * obj0 = 0 ;
10065 PyObject * obj1 = 0 ;
10066 PyObject * obj2 = 0 ;
10067 PyObject * obj3 = 0 ;
10068 char *kwnames[] = {
10069 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10070 };
10071
10072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10074 if (SWIG_arg_fail(1)) SWIG_fail;
10075 if (obj1) {
10076 {
10077 arg2 = (int)(SWIG_As_int(obj1));
10078 if (SWIG_arg_fail(2)) SWIG_fail;
10079 }
10080 }
10081 if (obj2) {
10082 {
10083 arg3 = (int)(SWIG_As_int(obj2));
10084 if (SWIG_arg_fail(3)) SWIG_fail;
10085 }
10086 }
10087 if (obj3) {
10088 {
10089 arg4 = (bool)(SWIG_As_bool(obj3));
10090 if (SWIG_arg_fail(4)) SWIG_fail;
10091 }
10092 }
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10096
10097 wxPyEndAllowThreads(__tstate);
10098 if (PyErr_Occurred()) SWIG_fail;
10099 }
10100 {
10101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10102 }
10103 return resultobj;
10104 fail:
10105 return NULL;
10106 }
10107
10108
10109 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10110 PyObject *resultobj;
10111 wxGrid *arg1 = (wxGrid *) 0 ;
10112 int arg2 = (int) 1 ;
10113 bool arg3 = (bool) true ;
10114 bool result;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 PyObject * obj2 = 0 ;
10118 char *kwnames[] = {
10119 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10120 };
10121
10122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10124 if (SWIG_arg_fail(1)) SWIG_fail;
10125 if (obj1) {
10126 {
10127 arg2 = (int)(SWIG_As_int(obj1));
10128 if (SWIG_arg_fail(2)) SWIG_fail;
10129 }
10130 }
10131 if (obj2) {
10132 {
10133 arg3 = (bool)(SWIG_As_bool(obj2));
10134 if (SWIG_arg_fail(3)) SWIG_fail;
10135 }
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 result = (bool)(arg1)->AppendRows(arg2,arg3);
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 {
10145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10146 }
10147 return resultobj;
10148 fail:
10149 return NULL;
10150 }
10151
10152
10153 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxGrid *arg1 = (wxGrid *) 0 ;
10156 int arg2 = (int) 0 ;
10157 int arg3 = (int) 1 ;
10158 bool arg4 = (bool) true ;
10159 bool result;
10160 PyObject * obj0 = 0 ;
10161 PyObject * obj1 = 0 ;
10162 PyObject * obj2 = 0 ;
10163 PyObject * obj3 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 if (obj1) {
10172 {
10173 arg2 = (int)(SWIG_As_int(obj1));
10174 if (SWIG_arg_fail(2)) SWIG_fail;
10175 }
10176 }
10177 if (obj2) {
10178 {
10179 arg3 = (int)(SWIG_As_int(obj2));
10180 if (SWIG_arg_fail(3)) SWIG_fail;
10181 }
10182 }
10183 if (obj3) {
10184 {
10185 arg4 = (bool)(SWIG_As_bool(obj3));
10186 if (SWIG_arg_fail(4)) SWIG_fail;
10187 }
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10192
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 {
10197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10198 }
10199 return resultobj;
10200 fail:
10201 return NULL;
10202 }
10203
10204
10205 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj;
10207 wxGrid *arg1 = (wxGrid *) 0 ;
10208 int arg2 = (int) 0 ;
10209 int arg3 = (int) 1 ;
10210 bool arg4 = (bool) true ;
10211 bool result;
10212 PyObject * obj0 = 0 ;
10213 PyObject * obj1 = 0 ;
10214 PyObject * obj2 = 0 ;
10215 PyObject * obj3 = 0 ;
10216 char *kwnames[] = {
10217 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10218 };
10219
10220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10222 if (SWIG_arg_fail(1)) SWIG_fail;
10223 if (obj1) {
10224 {
10225 arg2 = (int)(SWIG_As_int(obj1));
10226 if (SWIG_arg_fail(2)) SWIG_fail;
10227 }
10228 }
10229 if (obj2) {
10230 {
10231 arg3 = (int)(SWIG_As_int(obj2));
10232 if (SWIG_arg_fail(3)) SWIG_fail;
10233 }
10234 }
10235 if (obj3) {
10236 {
10237 arg4 = (bool)(SWIG_As_bool(obj3));
10238 if (SWIG_arg_fail(4)) SWIG_fail;
10239 }
10240 }
10241 {
10242 PyThreadState* __tstate = wxPyBeginAllowThreads();
10243 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10244
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 {
10249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10250 }
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10258 PyObject *resultobj;
10259 wxGrid *arg1 = (wxGrid *) 0 ;
10260 int arg2 = (int) 1 ;
10261 bool arg3 = (bool) true ;
10262 bool result;
10263 PyObject * obj0 = 0 ;
10264 PyObject * obj1 = 0 ;
10265 PyObject * obj2 = 0 ;
10266 char *kwnames[] = {
10267 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10268 };
10269
10270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10272 if (SWIG_arg_fail(1)) SWIG_fail;
10273 if (obj1) {
10274 {
10275 arg2 = (int)(SWIG_As_int(obj1));
10276 if (SWIG_arg_fail(2)) SWIG_fail;
10277 }
10278 }
10279 if (obj2) {
10280 {
10281 arg3 = (bool)(SWIG_As_bool(obj2));
10282 if (SWIG_arg_fail(3)) SWIG_fail;
10283 }
10284 }
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 result = (bool)(arg1)->AppendCols(arg2,arg3);
10288
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 {
10293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10294 }
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj;
10303 wxGrid *arg1 = (wxGrid *) 0 ;
10304 int arg2 = (int) 0 ;
10305 int arg3 = (int) 1 ;
10306 bool arg4 = (bool) true ;
10307 bool result;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 PyObject * obj2 = 0 ;
10311 PyObject * obj3 = 0 ;
10312 char *kwnames[] = {
10313 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10314 };
10315
10316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10318 if (SWIG_arg_fail(1)) SWIG_fail;
10319 if (obj1) {
10320 {
10321 arg2 = (int)(SWIG_As_int(obj1));
10322 if (SWIG_arg_fail(2)) SWIG_fail;
10323 }
10324 }
10325 if (obj2) {
10326 {
10327 arg3 = (int)(SWIG_As_int(obj2));
10328 if (SWIG_arg_fail(3)) SWIG_fail;
10329 }
10330 }
10331 if (obj3) {
10332 {
10333 arg4 = (bool)(SWIG_As_bool(obj3));
10334 if (SWIG_arg_fail(4)) SWIG_fail;
10335 }
10336 }
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10340
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 {
10345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10346 }
10347 return resultobj;
10348 fail:
10349 return NULL;
10350 }
10351
10352
10353 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj;
10355 wxGrid *arg1 = (wxGrid *) 0 ;
10356 wxDC *arg2 = 0 ;
10357 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 PyObject * obj2 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "self",(char *) "dc",(char *) "attr", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10367 if (SWIG_arg_fail(1)) SWIG_fail;
10368 {
10369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10370 if (SWIG_arg_fail(2)) SWIG_fail;
10371 if (arg2 == NULL) {
10372 SWIG_null_ref("wxDC");
10373 }
10374 if (SWIG_arg_fail(2)) SWIG_fail;
10375 }
10376 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10377 if (SWIG_arg_fail(3)) SWIG_fail;
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 Py_INCREF(Py_None); resultobj = Py_None;
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj;
10394 wxGrid *arg1 = (wxGrid *) 0 ;
10395 wxDC *arg2 = 0 ;
10396 wxString *arg3 = 0 ;
10397 wxRect *arg4 = 0 ;
10398 int arg5 = (int) wxLEFT ;
10399 int arg6 = (int) wxTOP ;
10400 int arg7 = (int) wxHORIZONTAL ;
10401 bool temp3 = false ;
10402 wxRect temp4 ;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 PyObject * obj2 = 0 ;
10406 PyObject * obj3 = 0 ;
10407 PyObject * obj4 = 0 ;
10408 PyObject * obj5 = 0 ;
10409 PyObject * obj6 = 0 ;
10410 char *kwnames[] = {
10411 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10412 };
10413
10414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10416 if (SWIG_arg_fail(1)) SWIG_fail;
10417 {
10418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10419 if (SWIG_arg_fail(2)) SWIG_fail;
10420 if (arg2 == NULL) {
10421 SWIG_null_ref("wxDC");
10422 }
10423 if (SWIG_arg_fail(2)) SWIG_fail;
10424 }
10425 {
10426 arg3 = wxString_in_helper(obj2);
10427 if (arg3 == NULL) SWIG_fail;
10428 temp3 = true;
10429 }
10430 {
10431 arg4 = &temp4;
10432 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10433 }
10434 if (obj4) {
10435 {
10436 arg5 = (int)(SWIG_As_int(obj4));
10437 if (SWIG_arg_fail(5)) SWIG_fail;
10438 }
10439 }
10440 if (obj5) {
10441 {
10442 arg6 = (int)(SWIG_As_int(obj5));
10443 if (SWIG_arg_fail(6)) SWIG_fail;
10444 }
10445 }
10446 if (obj6) {
10447 {
10448 arg7 = (int)(SWIG_As_int(obj6));
10449 if (SWIG_arg_fail(7)) SWIG_fail;
10450 }
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 {
10461 if (temp3)
10462 delete arg3;
10463 }
10464 return resultobj;
10465 fail:
10466 {
10467 if (temp3)
10468 delete arg3;
10469 }
10470 return NULL;
10471 }
10472
10473
10474 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj;
10476 wxGrid *arg1 = (wxGrid *) 0 ;
10477 wxDC *arg2 = 0 ;
10478 wxArrayString *arg3 = 0 ;
10479 long *arg4 = (long *) 0 ;
10480 long *arg5 = (long *) 0 ;
10481 bool temp3 = false ;
10482 long temp4 ;
10483 int res4 = 0 ;
10484 long temp5 ;
10485 int res5 = 0 ;
10486 PyObject * obj0 = 0 ;
10487 PyObject * obj1 = 0 ;
10488 PyObject * obj2 = 0 ;
10489 char *kwnames[] = {
10490 (char *) "self",(char *) "dc",(char *) "lines", NULL
10491 };
10492
10493 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10494 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10497 if (SWIG_arg_fail(1)) SWIG_fail;
10498 {
10499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10500 if (SWIG_arg_fail(2)) SWIG_fail;
10501 if (arg2 == NULL) {
10502 SWIG_null_ref("wxDC");
10503 }
10504 if (SWIG_arg_fail(2)) SWIG_fail;
10505 }
10506 {
10507 if (! PySequence_Check(obj2)) {
10508 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10509 SWIG_fail;
10510 }
10511 arg3 = new wxArrayString;
10512 temp3 = true;
10513 int i, len=PySequence_Length(obj2);
10514 for (i=0; i<len; i++) {
10515 PyObject* item = PySequence_GetItem(obj2, i);
10516 #if wxUSE_UNICODE
10517 PyObject* str = PyObject_Unicode(item);
10518 #else
10519 PyObject* str = PyObject_Str(item);
10520 #endif
10521 if (PyErr_Occurred()) SWIG_fail;
10522 arg3->Add(Py2wxString(str));
10523 Py_DECREF(item);
10524 Py_DECREF(str);
10525 }
10526 }
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10530
10531 wxPyEndAllowThreads(__tstate);
10532 if (PyErr_Occurred()) SWIG_fail;
10533 }
10534 Py_INCREF(Py_None); resultobj = Py_None;
10535 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10536 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10537 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10538 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10539 {
10540 if (temp3) delete arg3;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp3) delete arg3;
10546 }
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxGrid *arg1 = (wxGrid *) 0 ;
10554 PyObject * obj0 = 0 ;
10555 char *kwnames[] = {
10556 (char *) "self", NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10561 if (SWIG_arg_fail(1)) SWIG_fail;
10562 {
10563 PyThreadState* __tstate = wxPyBeginAllowThreads();
10564 (arg1)->BeginBatch();
10565
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 Py_INCREF(Py_None); resultobj = Py_None;
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj;
10578 wxGrid *arg1 = (wxGrid *) 0 ;
10579 PyObject * obj0 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "self", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10586 if (SWIG_arg_fail(1)) SWIG_fail;
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 (arg1)->EndBatch();
10590
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 Py_INCREF(Py_None); resultobj = Py_None;
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj;
10603 wxGrid *arg1 = (wxGrid *) 0 ;
10604 int result;
10605 PyObject * obj0 = 0 ;
10606 char *kwnames[] = {
10607 (char *) "self", NULL
10608 };
10609
10610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10612 if (SWIG_arg_fail(1)) SWIG_fail;
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 result = (int)(arg1)->GetBatchCount();
10616
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 {
10621 resultobj = SWIG_From_int((int)(result));
10622 }
10623 return resultobj;
10624 fail:
10625 return NULL;
10626 }
10627
10628
10629 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10630 PyObject *resultobj;
10631 wxGrid *arg1 = (wxGrid *) 0 ;
10632 PyObject * obj0 = 0 ;
10633 char *kwnames[] = {
10634 (char *) "self", NULL
10635 };
10636
10637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10639 if (SWIG_arg_fail(1)) SWIG_fail;
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 (arg1)->ForceRefresh();
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 Py_INCREF(Py_None); resultobj = Py_None;
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 wxGrid *arg1 = (wxGrid *) 0 ;
10657 bool result;
10658 PyObject * obj0 = 0 ;
10659 char *kwnames[] = {
10660 (char *) "self", NULL
10661 };
10662
10663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10665 if (SWIG_arg_fail(1)) SWIG_fail;
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 result = (bool)(arg1)->IsEditable();
10669
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10675 }
10676 return resultobj;
10677 fail:
10678 return NULL;
10679 }
10680
10681
10682 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10683 PyObject *resultobj;
10684 wxGrid *arg1 = (wxGrid *) 0 ;
10685 bool arg2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "self",(char *) "edit", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10694 if (SWIG_arg_fail(1)) SWIG_fail;
10695 {
10696 arg2 = (bool)(SWIG_As_bool(obj1));
10697 if (SWIG_arg_fail(2)) SWIG_fail;
10698 }
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 (arg1)->EnableEditing(arg2);
10702
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 Py_INCREF(Py_None); resultobj = Py_None;
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj;
10715 wxGrid *arg1 = (wxGrid *) 0 ;
10716 bool arg2 = (bool) true ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 char *kwnames[] = {
10720 (char *) "self",(char *) "enable", NULL
10721 };
10722
10723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(1)) SWIG_fail;
10726 if (obj1) {
10727 {
10728 arg2 = (bool)(SWIG_As_bool(obj1));
10729 if (SWIG_arg_fail(2)) SWIG_fail;
10730 }
10731 }
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 (arg1)->EnableCellEditControl(arg2);
10735
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 Py_INCREF(Py_None); resultobj = Py_None;
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj;
10748 wxGrid *arg1 = (wxGrid *) 0 ;
10749 PyObject * obj0 = 0 ;
10750 char *kwnames[] = {
10751 (char *) "self", NULL
10752 };
10753
10754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(1)) SWIG_fail;
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->DisableCellEditControl();
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj;
10773 wxGrid *arg1 = (wxGrid *) 0 ;
10774 bool result;
10775 PyObject * obj0 = 0 ;
10776 char *kwnames[] = {
10777 (char *) "self", NULL
10778 };
10779
10780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10782 if (SWIG_arg_fail(1)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10792 }
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj;
10801 wxGrid *arg1 = (wxGrid *) 0 ;
10802 bool result;
10803 PyObject * obj0 = 0 ;
10804 char *kwnames[] = {
10805 (char *) "self", NULL
10806 };
10807
10808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
10809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10810 if (SWIG_arg_fail(1)) SWIG_fail;
10811 {
10812 PyThreadState* __tstate = wxPyBeginAllowThreads();
10813 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
10814
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 {
10819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10820 }
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj;
10829 wxGrid *arg1 = (wxGrid *) 0 ;
10830 bool result;
10831 PyObject * obj0 = 0 ;
10832 char *kwnames[] = {
10833 (char *) "self", NULL
10834 };
10835
10836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
10837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10838 if (SWIG_arg_fail(1)) SWIG_fail;
10839 {
10840 PyThreadState* __tstate = wxPyBeginAllowThreads();
10841 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
10842
10843 wxPyEndAllowThreads(__tstate);
10844 if (PyErr_Occurred()) SWIG_fail;
10845 }
10846 {
10847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10848 }
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj;
10857 wxGrid *arg1 = (wxGrid *) 0 ;
10858 bool result;
10859 PyObject * obj0 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "self", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
10865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10866 if (SWIG_arg_fail(1)) SWIG_fail;
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
10870
10871 wxPyEndAllowThreads(__tstate);
10872 if (PyErr_Occurred()) SWIG_fail;
10873 }
10874 {
10875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10876 }
10877 return resultobj;
10878 fail:
10879 return NULL;
10880 }
10881
10882
10883 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10884 PyObject *resultobj;
10885 wxGrid *arg1 = (wxGrid *) 0 ;
10886 PyObject * obj0 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 PyThreadState* __tstate = wxPyBeginAllowThreads();
10896 (arg1)->ShowCellEditControl();
10897
10898 wxPyEndAllowThreads(__tstate);
10899 if (PyErr_Occurred()) SWIG_fail;
10900 }
10901 Py_INCREF(Py_None); resultobj = Py_None;
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10909 PyObject *resultobj;
10910 wxGrid *arg1 = (wxGrid *) 0 ;
10911 PyObject * obj0 = 0 ;
10912 char *kwnames[] = {
10913 (char *) "self", NULL
10914 };
10915
10916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
10917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10918 if (SWIG_arg_fail(1)) SWIG_fail;
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 (arg1)->HideCellEditControl();
10922
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 Py_INCREF(Py_None); resultobj = Py_None;
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxGrid *arg1 = (wxGrid *) 0 ;
10936 PyObject * obj0 = 0 ;
10937 char *kwnames[] = {
10938 (char *) "self", NULL
10939 };
10940
10941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
10942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10943 if (SWIG_arg_fail(1)) SWIG_fail;
10944 {
10945 PyThreadState* __tstate = wxPyBeginAllowThreads();
10946 (arg1)->SaveEditControlValue();
10947
10948 wxPyEndAllowThreads(__tstate);
10949 if (PyErr_Occurred()) SWIG_fail;
10950 }
10951 Py_INCREF(Py_None); resultobj = Py_None;
10952 return resultobj;
10953 fail:
10954 return NULL;
10955 }
10956
10957
10958 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
10959 PyObject *resultobj;
10960 wxGrid *arg1 = (wxGrid *) 0 ;
10961 int arg2 ;
10962 int arg3 ;
10963 wxGridCellCoords result;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 PyObject * obj2 = 0 ;
10967 char *kwnames[] = {
10968 (char *) "self",(char *) "x",(char *) "y", NULL
10969 };
10970
10971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
10972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10973 if (SWIG_arg_fail(1)) SWIG_fail;
10974 {
10975 arg2 = (int)(SWIG_As_int(obj1));
10976 if (SWIG_arg_fail(2)) SWIG_fail;
10977 }
10978 {
10979 arg3 = (int)(SWIG_As_int(obj2));
10980 if (SWIG_arg_fail(3)) SWIG_fail;
10981 }
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 result = wxGrid_XYToCell(arg1,arg2,arg3);
10985
10986 wxPyEndAllowThreads(__tstate);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 {
10990 wxGridCellCoords * resultptr;
10991 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
10992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
10993 }
10994 return resultobj;
10995 fail:
10996 return NULL;
10997 }
10998
10999
11000 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
11001 PyObject *resultobj;
11002 wxGrid *arg1 = (wxGrid *) 0 ;
11003 int arg2 ;
11004 int result;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "y", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = (int)(SWIG_As_int(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (int)(arg1)->YToRow(arg2);
11021
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 {
11026 resultobj = SWIG_From_int((int)(result));
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj;
11036 wxGrid *arg1 = (wxGrid *) 0 ;
11037 int arg2 ;
11038 int result;
11039 PyObject * obj0 = 0 ;
11040 PyObject * obj1 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self",(char *) "x", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 result = (int)(arg1)->XToCol(arg2);
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 {
11060 resultobj = SWIG_From_int((int)(result));
11061 }
11062 return resultobj;
11063 fail:
11064 return NULL;
11065 }
11066
11067
11068 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj;
11070 wxGrid *arg1 = (wxGrid *) 0 ;
11071 int arg2 ;
11072 int result;
11073 PyObject * obj0 = 0 ;
11074 PyObject * obj1 = 0 ;
11075 char *kwnames[] = {
11076 (char *) "self",(char *) "y", NULL
11077 };
11078
11079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11081 if (SWIG_arg_fail(1)) SWIG_fail;
11082 {
11083 arg2 = (int)(SWIG_As_int(obj1));
11084 if (SWIG_arg_fail(2)) SWIG_fail;
11085 }
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (int)(arg1)->YToEdgeOfRow(arg2);
11089
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = SWIG_From_int((int)(result));
11095 }
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj;
11104 wxGrid *arg1 = (wxGrid *) 0 ;
11105 int arg2 ;
11106 int result;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 char *kwnames[] = {
11110 (char *) "self",(char *) "x", NULL
11111 };
11112
11113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11115 if (SWIG_arg_fail(1)) SWIG_fail;
11116 {
11117 arg2 = (int)(SWIG_As_int(obj1));
11118 if (SWIG_arg_fail(2)) SWIG_fail;
11119 }
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 result = (int)(arg1)->XToEdgeOfCol(arg2);
11123
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 {
11128 resultobj = SWIG_From_int((int)(result));
11129 }
11130 return resultobj;
11131 fail:
11132 return NULL;
11133 }
11134
11135
11136 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11137 PyObject *resultobj;
11138 wxGrid *arg1 = (wxGrid *) 0 ;
11139 int arg2 ;
11140 int arg3 ;
11141 wxRect result;
11142 PyObject * obj0 = 0 ;
11143 PyObject * obj1 = 0 ;
11144 PyObject * obj2 = 0 ;
11145 char *kwnames[] = {
11146 (char *) "self",(char *) "row",(char *) "col", NULL
11147 };
11148
11149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11151 if (SWIG_arg_fail(1)) SWIG_fail;
11152 {
11153 arg2 = (int)(SWIG_As_int(obj1));
11154 if (SWIG_arg_fail(2)) SWIG_fail;
11155 }
11156 {
11157 arg3 = (int)(SWIG_As_int(obj2));
11158 if (SWIG_arg_fail(3)) SWIG_fail;
11159 }
11160 {
11161 PyThreadState* __tstate = wxPyBeginAllowThreads();
11162 result = (arg1)->CellToRect(arg2,arg3);
11163
11164 wxPyEndAllowThreads(__tstate);
11165 if (PyErr_Occurred()) SWIG_fail;
11166 }
11167 {
11168 wxRect * resultptr;
11169 resultptr = new wxRect((wxRect &)(result));
11170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11171 }
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11179 PyObject *resultobj;
11180 wxGrid *arg1 = (wxGrid *) 0 ;
11181 int result;
11182 PyObject * obj0 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 result = (int)(arg1)->GetGridCursorRow();
11193
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 {
11198 resultobj = SWIG_From_int((int)(result));
11199 }
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj;
11208 wxGrid *arg1 = (wxGrid *) 0 ;
11209 int result;
11210 PyObject * obj0 = 0 ;
11211 char *kwnames[] = {
11212 (char *) "self", NULL
11213 };
11214
11215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11217 if (SWIG_arg_fail(1)) SWIG_fail;
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 result = (int)(arg1)->GetGridCursorCol();
11221
11222 wxPyEndAllowThreads(__tstate);
11223 if (PyErr_Occurred()) SWIG_fail;
11224 }
11225 {
11226 resultobj = SWIG_From_int((int)(result));
11227 }
11228 return resultobj;
11229 fail:
11230 return NULL;
11231 }
11232
11233
11234 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11235 PyObject *resultobj;
11236 wxGrid *arg1 = (wxGrid *) 0 ;
11237 int arg2 ;
11238 int arg3 ;
11239 bool arg4 = (bool) true ;
11240 bool result;
11241 PyObject * obj0 = 0 ;
11242 PyObject * obj1 = 0 ;
11243 PyObject * obj2 = 0 ;
11244 PyObject * obj3 = 0 ;
11245 char *kwnames[] = {
11246 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11247 };
11248
11249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11251 if (SWIG_arg_fail(1)) SWIG_fail;
11252 {
11253 arg2 = (int)(SWIG_As_int(obj1));
11254 if (SWIG_arg_fail(2)) SWIG_fail;
11255 }
11256 {
11257 arg3 = (int)(SWIG_As_int(obj2));
11258 if (SWIG_arg_fail(3)) SWIG_fail;
11259 }
11260 if (obj3) {
11261 {
11262 arg4 = (bool)(SWIG_As_bool(obj3));
11263 if (SWIG_arg_fail(4)) SWIG_fail;
11264 }
11265 }
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11269
11270 wxPyEndAllowThreads(__tstate);
11271 if (PyErr_Occurred()) SWIG_fail;
11272 }
11273 {
11274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11275 }
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj;
11284 wxGrid *arg1 = (wxGrid *) 0 ;
11285 int arg2 ;
11286 int arg3 ;
11287 PyObject * obj0 = 0 ;
11288 PyObject * obj1 = 0 ;
11289 PyObject * obj2 = 0 ;
11290 char *kwnames[] = {
11291 (char *) "self",(char *) "row",(char *) "col", NULL
11292 };
11293
11294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11296 if (SWIG_arg_fail(1)) SWIG_fail;
11297 {
11298 arg2 = (int)(SWIG_As_int(obj1));
11299 if (SWIG_arg_fail(2)) SWIG_fail;
11300 }
11301 {
11302 arg3 = (int)(SWIG_As_int(obj2));
11303 if (SWIG_arg_fail(3)) SWIG_fail;
11304 }
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 (arg1)->MakeCellVisible(arg2,arg3);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 Py_INCREF(Py_None); resultobj = Py_None;
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 wxGrid *arg1 = (wxGrid *) 0 ;
11322 int arg2 ;
11323 int arg3 ;
11324 PyObject * obj0 = 0 ;
11325 PyObject * obj1 = 0 ;
11326 PyObject * obj2 = 0 ;
11327 char *kwnames[] = {
11328 (char *) "self",(char *) "row",(char *) "col", NULL
11329 };
11330
11331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11333 if (SWIG_arg_fail(1)) SWIG_fail;
11334 {
11335 arg2 = (int)(SWIG_As_int(obj1));
11336 if (SWIG_arg_fail(2)) SWIG_fail;
11337 }
11338 {
11339 arg3 = (int)(SWIG_As_int(obj2));
11340 if (SWIG_arg_fail(3)) SWIG_fail;
11341 }
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 (arg1)->SetGridCursor(arg2,arg3);
11345
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 Py_INCREF(Py_None); resultobj = Py_None;
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj;
11358 wxGrid *arg1 = (wxGrid *) 0 ;
11359 bool arg2 ;
11360 bool result;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "self",(char *) "expandSelection", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11369 if (SWIG_arg_fail(1)) SWIG_fail;
11370 {
11371 arg2 = (bool)(SWIG_As_bool(obj1));
11372 if (SWIG_arg_fail(2)) SWIG_fail;
11373 }
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (bool)(arg1)->MoveCursorUp(arg2);
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxGrid *arg1 = (wxGrid *) 0 ;
11393 bool arg2 ;
11394 bool result;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 char *kwnames[] = {
11398 (char *) "self",(char *) "expandSelection", NULL
11399 };
11400
11401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11403 if (SWIG_arg_fail(1)) SWIG_fail;
11404 {
11405 arg2 = (bool)(SWIG_As_bool(obj1));
11406 if (SWIG_arg_fail(2)) SWIG_fail;
11407 }
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 result = (bool)(arg1)->MoveCursorDown(arg2);
11411
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 {
11416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11417 }
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxGrid *arg1 = (wxGrid *) 0 ;
11427 bool arg2 ;
11428 bool result;
11429 PyObject * obj0 = 0 ;
11430 PyObject * obj1 = 0 ;
11431 char *kwnames[] = {
11432 (char *) "self",(char *) "expandSelection", NULL
11433 };
11434
11435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 {
11439 arg2 = (bool)(SWIG_As_bool(obj1));
11440 if (SWIG_arg_fail(2)) SWIG_fail;
11441 }
11442 {
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 result = (bool)(arg1)->MoveCursorLeft(arg2);
11445
11446 wxPyEndAllowThreads(__tstate);
11447 if (PyErr_Occurred()) SWIG_fail;
11448 }
11449 {
11450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11451 }
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11459 PyObject *resultobj;
11460 wxGrid *arg1 = (wxGrid *) 0 ;
11461 bool arg2 ;
11462 bool result;
11463 PyObject * obj0 = 0 ;
11464 PyObject * obj1 = 0 ;
11465 char *kwnames[] = {
11466 (char *) "self",(char *) "expandSelection", NULL
11467 };
11468
11469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11471 if (SWIG_arg_fail(1)) SWIG_fail;
11472 {
11473 arg2 = (bool)(SWIG_As_bool(obj1));
11474 if (SWIG_arg_fail(2)) SWIG_fail;
11475 }
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (bool)(arg1)->MoveCursorRight(arg2);
11479
11480 wxPyEndAllowThreads(__tstate);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 }
11483 {
11484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj;
11494 wxGrid *arg1 = (wxGrid *) 0 ;
11495 bool result;
11496 PyObject * obj0 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "self", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11503 if (SWIG_arg_fail(1)) SWIG_fail;
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 result = (bool)(arg1)->MovePageDown();
11507
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 {
11512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11513 }
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11521 PyObject *resultobj;
11522 wxGrid *arg1 = (wxGrid *) 0 ;
11523 bool result;
11524 PyObject * obj0 = 0 ;
11525 char *kwnames[] = {
11526 (char *) "self", NULL
11527 };
11528
11529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (bool)(arg1)->MovePageUp();
11535
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 {
11540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11541 }
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 static PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11549 PyObject *resultobj;
11550 wxGrid *arg1 = (wxGrid *) 0 ;
11551 bool arg2 ;
11552 bool result;
11553 PyObject * obj0 = 0 ;
11554 PyObject * obj1 = 0 ;
11555 char *kwnames[] = {
11556 (char *) "self",(char *) "expandSelection", NULL
11557 };
11558
11559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) goto fail;
11560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11561 if (SWIG_arg_fail(1)) SWIG_fail;
11562 {
11563 arg2 = (bool)(SWIG_As_bool(obj1));
11564 if (SWIG_arg_fail(2)) SWIG_fail;
11565 }
11566 {
11567 PyThreadState* __tstate = wxPyBeginAllowThreads();
11568 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
11569
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 {
11574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11575 }
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 static PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj;
11584 wxGrid *arg1 = (wxGrid *) 0 ;
11585 bool arg2 ;
11586 bool result;
11587 PyObject * obj0 = 0 ;
11588 PyObject * obj1 = 0 ;
11589 char *kwnames[] = {
11590 (char *) "self",(char *) "expandSelection", NULL
11591 };
11592
11593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) goto fail;
11594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11595 if (SWIG_arg_fail(1)) SWIG_fail;
11596 {
11597 arg2 = (bool)(SWIG_As_bool(obj1));
11598 if (SWIG_arg_fail(2)) SWIG_fail;
11599 }
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
11603
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11609 }
11610 return resultobj;
11611 fail:
11612 return NULL;
11613 }
11614
11615
11616 static PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11617 PyObject *resultobj;
11618 wxGrid *arg1 = (wxGrid *) 0 ;
11619 bool arg2 ;
11620 bool result;
11621 PyObject * obj0 = 0 ;
11622 PyObject * obj1 = 0 ;
11623 char *kwnames[] = {
11624 (char *) "self",(char *) "expandSelection", NULL
11625 };
11626
11627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) goto fail;
11628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11629 if (SWIG_arg_fail(1)) SWIG_fail;
11630 {
11631 arg2 = (bool)(SWIG_As_bool(obj1));
11632 if (SWIG_arg_fail(2)) SWIG_fail;
11633 }
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
11637
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11643 }
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11651 PyObject *resultobj;
11652 wxGrid *arg1 = (wxGrid *) 0 ;
11653 bool arg2 ;
11654 bool result;
11655 PyObject * obj0 = 0 ;
11656 PyObject * obj1 = 0 ;
11657 char *kwnames[] = {
11658 (char *) "self",(char *) "expandSelection", NULL
11659 };
11660
11661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11663 if (SWIG_arg_fail(1)) SWIG_fail;
11664 {
11665 arg2 = (bool)(SWIG_As_bool(obj1));
11666 if (SWIG_arg_fail(2)) SWIG_fail;
11667 }
11668 {
11669 PyThreadState* __tstate = wxPyBeginAllowThreads();
11670 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11671
11672 wxPyEndAllowThreads(__tstate);
11673 if (PyErr_Occurred()) SWIG_fail;
11674 }
11675 {
11676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677 }
11678 return resultobj;
11679 fail:
11680 return NULL;
11681 }
11682
11683
11684 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11685 PyObject *resultobj;
11686 wxGrid *arg1 = (wxGrid *) 0 ;
11687 int result;
11688 PyObject * obj0 = 0 ;
11689 char *kwnames[] = {
11690 (char *) "self", NULL
11691 };
11692
11693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11695 if (SWIG_arg_fail(1)) SWIG_fail;
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (int)(arg1)->GetDefaultRowLabelSize();
11699
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 {
11704 resultobj = SWIG_From_int((int)(result));
11705 }
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11713 PyObject *resultobj;
11714 wxGrid *arg1 = (wxGrid *) 0 ;
11715 int result;
11716 PyObject * obj0 = 0 ;
11717 char *kwnames[] = {
11718 (char *) "self", NULL
11719 };
11720
11721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11723 if (SWIG_arg_fail(1)) SWIG_fail;
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (int)(arg1)->GetRowLabelSize();
11727
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 resultobj = SWIG_From_int((int)(result));
11733 }
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11741 PyObject *resultobj;
11742 wxGrid *arg1 = (wxGrid *) 0 ;
11743 int result;
11744 PyObject * obj0 = 0 ;
11745 char *kwnames[] = {
11746 (char *) "self", NULL
11747 };
11748
11749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11751 if (SWIG_arg_fail(1)) SWIG_fail;
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (int)(arg1)->GetDefaultColLabelSize();
11755
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 resultobj = SWIG_From_int((int)(result));
11761 }
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11769 PyObject *resultobj;
11770 wxGrid *arg1 = (wxGrid *) 0 ;
11771 int result;
11772 PyObject * obj0 = 0 ;
11773 char *kwnames[] = {
11774 (char *) "self", NULL
11775 };
11776
11777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11779 if (SWIG_arg_fail(1)) SWIG_fail;
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (int)(arg1)->GetColLabelSize();
11783
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 resultobj = SWIG_From_int((int)(result));
11789 }
11790 return resultobj;
11791 fail:
11792 return NULL;
11793 }
11794
11795
11796 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj;
11798 wxGrid *arg1 = (wxGrid *) 0 ;
11799 wxColour result;
11800 PyObject * obj0 = 0 ;
11801 char *kwnames[] = {
11802 (char *) "self", NULL
11803 };
11804
11805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
11806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11807 if (SWIG_arg_fail(1)) SWIG_fail;
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (arg1)->GetLabelBackgroundColour();
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 wxColour * resultptr;
11817 resultptr = new wxColour((wxColour &)(result));
11818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11819 }
11820 return resultobj;
11821 fail:
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj;
11828 wxGrid *arg1 = (wxGrid *) 0 ;
11829 wxColour result;
11830 PyObject * obj0 = 0 ;
11831 char *kwnames[] = {
11832 (char *) "self", NULL
11833 };
11834
11835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
11836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11837 if (SWIG_arg_fail(1)) SWIG_fail;
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (arg1)->GetLabelTextColour();
11841
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 {
11846 wxColour * resultptr;
11847 resultptr = new wxColour((wxColour &)(result));
11848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11849 }
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
11857 PyObject *resultobj;
11858 wxGrid *arg1 = (wxGrid *) 0 ;
11859 wxFont result;
11860 PyObject * obj0 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (arg1)->GetLabelFont();
11871
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 wxFont * resultptr;
11877 resultptr = new wxFont((wxFont &)(result));
11878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
11879 }
11880 return resultobj;
11881 fail:
11882 return NULL;
11883 }
11884
11885
11886 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11887 PyObject *resultobj;
11888 wxGrid *arg1 = (wxGrid *) 0 ;
11889 int *arg2 = (int *) 0 ;
11890 int *arg3 = (int *) 0 ;
11891 int temp2 ;
11892 int res2 = 0 ;
11893 int temp3 ;
11894 int res3 = 0 ;
11895 PyObject * obj0 = 0 ;
11896 char *kwnames[] = {
11897 (char *) "self", NULL
11898 };
11899
11900 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11901 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
11903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11904 if (SWIG_arg_fail(1)) SWIG_fail;
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 (arg1)->GetRowLabelAlignment(arg2,arg3);
11908
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 Py_INCREF(Py_None); resultobj = Py_None;
11913 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11914 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11915 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11916 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11917 return resultobj;
11918 fail:
11919 return NULL;
11920 }
11921
11922
11923 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11924 PyObject *resultobj;
11925 wxGrid *arg1 = (wxGrid *) 0 ;
11926 int *arg2 = (int *) 0 ;
11927 int *arg3 = (int *) 0 ;
11928 int temp2 ;
11929 int res2 = 0 ;
11930 int temp3 ;
11931 int res3 = 0 ;
11932 PyObject * obj0 = 0 ;
11933 char *kwnames[] = {
11934 (char *) "self", NULL
11935 };
11936
11937 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11938 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
11940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11941 if (SWIG_arg_fail(1)) SWIG_fail;
11942 {
11943 PyThreadState* __tstate = wxPyBeginAllowThreads();
11944 (arg1)->GetColLabelAlignment(arg2,arg3);
11945
11946 wxPyEndAllowThreads(__tstate);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 Py_INCREF(Py_None); resultobj = Py_None;
11950 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11951 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11952 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11953 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
11961 PyObject *resultobj;
11962 wxGrid *arg1 = (wxGrid *) 0 ;
11963 int result;
11964 PyObject * obj0 = 0 ;
11965 char *kwnames[] = {
11966 (char *) "self", NULL
11967 };
11968
11969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
11970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11971 if (SWIG_arg_fail(1)) SWIG_fail;
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (int)(arg1)->GetColLabelTextOrientation();
11975
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 {
11980 resultobj = SWIG_From_int((int)(result));
11981 }
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj;
11990 wxGrid *arg1 = (wxGrid *) 0 ;
11991 int arg2 ;
11992 wxString result;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 char *kwnames[] = {
11996 (char *) "self",(char *) "row", NULL
11997 };
11998
11999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
12000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12001 if (SWIG_arg_fail(1)) SWIG_fail;
12002 {
12003 arg2 = (int)(SWIG_As_int(obj1));
12004 if (SWIG_arg_fail(2)) SWIG_fail;
12005 }
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (arg1)->GetRowLabelValue(arg2);
12009
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 #if wxUSE_UNICODE
12015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12016 #else
12017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12018 #endif
12019 }
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj;
12028 wxGrid *arg1 = (wxGrid *) 0 ;
12029 int arg2 ;
12030 wxString result;
12031 PyObject * obj0 = 0 ;
12032 PyObject * obj1 = 0 ;
12033 char *kwnames[] = {
12034 (char *) "self",(char *) "col", NULL
12035 };
12036
12037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12039 if (SWIG_arg_fail(1)) SWIG_fail;
12040 {
12041 arg2 = (int)(SWIG_As_int(obj1));
12042 if (SWIG_arg_fail(2)) SWIG_fail;
12043 }
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (arg1)->GetColLabelValue(arg2);
12047
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 #if wxUSE_UNICODE
12053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12054 #else
12055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12056 #endif
12057 }
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12065 PyObject *resultobj;
12066 wxGrid *arg1 = (wxGrid *) 0 ;
12067 wxColour result;
12068 PyObject * obj0 = 0 ;
12069 char *kwnames[] = {
12070 (char *) "self", NULL
12071 };
12072
12073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12075 if (SWIG_arg_fail(1)) SWIG_fail;
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (arg1)->GetGridLineColour();
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 {
12084 wxColour * resultptr;
12085 resultptr = new wxColour((wxColour &)(result));
12086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj;
12096 wxGrid *arg1 = (wxGrid *) 0 ;
12097 wxColour result;
12098 PyObject * obj0 = 0 ;
12099 char *kwnames[] = {
12100 (char *) "self", NULL
12101 };
12102
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (arg1)->GetCellHighlightColour();
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 wxColour * resultptr;
12115 resultptr = new wxColour((wxColour &)(result));
12116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxGrid *arg1 = (wxGrid *) 0 ;
12127 int result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (int)(arg1)->GetCellHighlightPenWidth();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = SWIG_From_int((int)(result));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxGrid *arg1 = (wxGrid *) 0 ;
12155 int result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (int)(arg1)->GetCellHighlightROPenWidth();
12167
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 {
12172 resultobj = SWIG_From_int((int)(result));
12173 }
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 wxGrid *arg1 = (wxGrid *) 0 ;
12183 int arg2 ;
12184 PyObject * obj0 = 0 ;
12185 PyObject * obj1 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self",(char *) "width", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 arg2 = (int)(SWIG_As_int(obj1));
12195 if (SWIG_arg_fail(2)) SWIG_fail;
12196 }
12197 {
12198 PyThreadState* __tstate = wxPyBeginAllowThreads();
12199 (arg1)->SetRowLabelSize(arg2);
12200
12201 wxPyEndAllowThreads(__tstate);
12202 if (PyErr_Occurred()) SWIG_fail;
12203 }
12204 Py_INCREF(Py_None); resultobj = Py_None;
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj;
12213 wxGrid *arg1 = (wxGrid *) 0 ;
12214 int arg2 ;
12215 PyObject * obj0 = 0 ;
12216 PyObject * obj1 = 0 ;
12217 char *kwnames[] = {
12218 (char *) "self",(char *) "height", NULL
12219 };
12220
12221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12223 if (SWIG_arg_fail(1)) SWIG_fail;
12224 {
12225 arg2 = (int)(SWIG_As_int(obj1));
12226 if (SWIG_arg_fail(2)) SWIG_fail;
12227 }
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 (arg1)->SetColLabelSize(arg2);
12231
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 Py_INCREF(Py_None); resultobj = Py_None;
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj;
12244 wxGrid *arg1 = (wxGrid *) 0 ;
12245 wxColour *arg2 = 0 ;
12246 wxColour temp2 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self","arg2", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 {
12257 arg2 = &temp2;
12258 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12259 }
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12263
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 Py_INCREF(Py_None); resultobj = Py_None;
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj;
12276 wxGrid *arg1 = (wxGrid *) 0 ;
12277 wxColour *arg2 = 0 ;
12278 wxColour temp2 ;
12279 PyObject * obj0 = 0 ;
12280 PyObject * obj1 = 0 ;
12281 char *kwnames[] = {
12282 (char *) "self","arg2", NULL
12283 };
12284
12285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) goto fail;
12286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12287 if (SWIG_arg_fail(1)) SWIG_fail;
12288 {
12289 arg2 = &temp2;
12290 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12291 }
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 Py_INCREF(Py_None); resultobj = Py_None;
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 static PyObject *_wrap_Grid_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj;
12308 wxGrid *arg1 = (wxGrid *) 0 ;
12309 wxFont *arg2 = 0 ;
12310 PyObject * obj0 = 0 ;
12311 PyObject * obj1 = 0 ;
12312 char *kwnames[] = {
12313 (char *) "self","arg2", NULL
12314 };
12315
12316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12318 if (SWIG_arg_fail(1)) SWIG_fail;
12319 {
12320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12321 if (SWIG_arg_fail(2)) SWIG_fail;
12322 if (arg2 == NULL) {
12323 SWIG_null_ref("wxFont");
12324 }
12325 if (SWIG_arg_fail(2)) SWIG_fail;
12326 }
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 (arg1)->SetLabelFont((wxFont const &)*arg2);
12330
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 Py_INCREF(Py_None); resultobj = Py_None;
12335 return resultobj;
12336 fail:
12337 return NULL;
12338 }
12339
12340
12341 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12342 PyObject *resultobj;
12343 wxGrid *arg1 = (wxGrid *) 0 ;
12344 int arg2 ;
12345 int arg3 ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 PyObject * obj2 = 0 ;
12349 char *kwnames[] = {
12350 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12351 };
12352
12353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(1)) SWIG_fail;
12356 {
12357 arg2 = (int)(SWIG_As_int(obj1));
12358 if (SWIG_arg_fail(2)) SWIG_fail;
12359 }
12360 {
12361 arg3 = (int)(SWIG_As_int(obj2));
12362 if (SWIG_arg_fail(3)) SWIG_fail;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 (arg1)->SetRowLabelAlignment(arg2,arg3);
12367
12368 wxPyEndAllowThreads(__tstate);
12369 if (PyErr_Occurred()) SWIG_fail;
12370 }
12371 Py_INCREF(Py_None); resultobj = Py_None;
12372 return resultobj;
12373 fail:
12374 return NULL;
12375 }
12376
12377
12378 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12379 PyObject *resultobj;
12380 wxGrid *arg1 = (wxGrid *) 0 ;
12381 int arg2 ;
12382 int arg3 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 PyObject * obj2 = 0 ;
12386 char *kwnames[] = {
12387 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12388 };
12389
12390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12392 if (SWIG_arg_fail(1)) SWIG_fail;
12393 {
12394 arg2 = (int)(SWIG_As_int(obj1));
12395 if (SWIG_arg_fail(2)) SWIG_fail;
12396 }
12397 {
12398 arg3 = (int)(SWIG_As_int(obj2));
12399 if (SWIG_arg_fail(3)) SWIG_fail;
12400 }
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 (arg1)->SetColLabelAlignment(arg2,arg3);
12404
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 Py_INCREF(Py_None); resultobj = Py_None;
12409 return resultobj;
12410 fail:
12411 return NULL;
12412 }
12413
12414
12415 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj;
12417 wxGrid *arg1 = (wxGrid *) 0 ;
12418 int arg2 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 char *kwnames[] = {
12422 (char *) "self",(char *) "textOrientation", NULL
12423 };
12424
12425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12427 if (SWIG_arg_fail(1)) SWIG_fail;
12428 {
12429 arg2 = (int)(SWIG_As_int(obj1));
12430 if (SWIG_arg_fail(2)) SWIG_fail;
12431 }
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 (arg1)->SetColLabelTextOrientation(arg2);
12435
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 Py_INCREF(Py_None); resultobj = Py_None;
12440 return resultobj;
12441 fail:
12442 return NULL;
12443 }
12444
12445
12446 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12447 PyObject *resultobj;
12448 wxGrid *arg1 = (wxGrid *) 0 ;
12449 int arg2 ;
12450 wxString *arg3 = 0 ;
12451 bool temp3 = false ;
12452 PyObject * obj0 = 0 ;
12453 PyObject * obj1 = 0 ;
12454 PyObject * obj2 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self",(char *) "row","arg3", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 arg2 = (int)(SWIG_As_int(obj1));
12464 if (SWIG_arg_fail(2)) SWIG_fail;
12465 }
12466 {
12467 arg3 = wxString_in_helper(obj2);
12468 if (arg3 == NULL) SWIG_fail;
12469 temp3 = true;
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12474
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 Py_INCREF(Py_None); resultobj = Py_None;
12479 {
12480 if (temp3)
12481 delete arg3;
12482 }
12483 return resultobj;
12484 fail:
12485 {
12486 if (temp3)
12487 delete arg3;
12488 }
12489 return NULL;
12490 }
12491
12492
12493 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12494 PyObject *resultobj;
12495 wxGrid *arg1 = (wxGrid *) 0 ;
12496 int arg2 ;
12497 wxString *arg3 = 0 ;
12498 bool temp3 = false ;
12499 PyObject * obj0 = 0 ;
12500 PyObject * obj1 = 0 ;
12501 PyObject * obj2 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self",(char *) "col","arg3", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 arg2 = (int)(SWIG_As_int(obj1));
12511 if (SWIG_arg_fail(2)) SWIG_fail;
12512 }
12513 {
12514 arg3 = wxString_in_helper(obj2);
12515 if (arg3 == NULL) SWIG_fail;
12516 temp3 = true;
12517 }
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 Py_INCREF(Py_None); resultobj = Py_None;
12526 {
12527 if (temp3)
12528 delete arg3;
12529 }
12530 return resultobj;
12531 fail:
12532 {
12533 if (temp3)
12534 delete arg3;
12535 }
12536 return NULL;
12537 }
12538
12539
12540 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12541 PyObject *resultobj;
12542 wxGrid *arg1 = (wxGrid *) 0 ;
12543 wxColour *arg2 = 0 ;
12544 wxColour temp2 ;
12545 PyObject * obj0 = 0 ;
12546 PyObject * obj1 = 0 ;
12547 char *kwnames[] = {
12548 (char *) "self","arg2", NULL
12549 };
12550
12551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12553 if (SWIG_arg_fail(1)) SWIG_fail;
12554 {
12555 arg2 = &temp2;
12556 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12557 }
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12561
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 Py_INCREF(Py_None); resultobj = Py_None;
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxGrid *arg1 = (wxGrid *) 0 ;
12575 wxColour *arg2 = 0 ;
12576 wxColour temp2 ;
12577 PyObject * obj0 = 0 ;
12578 PyObject * obj1 = 0 ;
12579 char *kwnames[] = {
12580 (char *) "self","arg2", NULL
12581 };
12582
12583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) goto fail;
12584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(1)) SWIG_fail;
12586 {
12587 arg2 = &temp2;
12588 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12589 }
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 Py_INCREF(Py_None); resultobj = Py_None;
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 static PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj;
12606 wxGrid *arg1 = (wxGrid *) 0 ;
12607 int arg2 ;
12608 PyObject * obj0 = 0 ;
12609 PyObject * obj1 = 0 ;
12610 char *kwnames[] = {
12611 (char *) "self",(char *) "width", NULL
12612 };
12613
12614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12616 if (SWIG_arg_fail(1)) SWIG_fail;
12617 {
12618 arg2 = (int)(SWIG_As_int(obj1));
12619 if (SWIG_arg_fail(2)) SWIG_fail;
12620 }
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 (arg1)->SetCellHighlightPenWidth(arg2);
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 Py_INCREF(Py_None); resultobj = Py_None;
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj;
12637 wxGrid *arg1 = (wxGrid *) 0 ;
12638 int arg2 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 char *kwnames[] = {
12642 (char *) "self",(char *) "width", NULL
12643 };
12644
12645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12647 if (SWIG_arg_fail(1)) SWIG_fail;
12648 {
12649 arg2 = (int)(SWIG_As_int(obj1));
12650 if (SWIG_arg_fail(2)) SWIG_fail;
12651 }
12652 {
12653 PyThreadState* __tstate = wxPyBeginAllowThreads();
12654 (arg1)->SetCellHighlightROPenWidth(arg2);
12655
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 Py_INCREF(Py_None); resultobj = Py_None;
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxGrid *arg1 = (wxGrid *) 0 ;
12669 bool arg2 = (bool) true ;
12670 PyObject * obj0 = 0 ;
12671 PyObject * obj1 = 0 ;
12672 char *kwnames[] = {
12673 (char *) "self",(char *) "enable", NULL
12674 };
12675
12676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12678 if (SWIG_arg_fail(1)) SWIG_fail;
12679 if (obj1) {
12680 {
12681 arg2 = (bool)(SWIG_As_bool(obj1));
12682 if (SWIG_arg_fail(2)) SWIG_fail;
12683 }
12684 }
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 (arg1)->EnableDragRowSize(arg2);
12688
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 Py_INCREF(Py_None); resultobj = Py_None;
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 static PyObject *_wrap_Grid_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj;
12701 wxGrid *arg1 = (wxGrid *) 0 ;
12702 PyObject * obj0 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 (arg1)->DisableDragRowSize();
12713
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 Py_INCREF(Py_None); resultobj = Py_None;
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj;
12726 wxGrid *arg1 = (wxGrid *) 0 ;
12727 bool result;
12728 PyObject * obj0 = 0 ;
12729 char *kwnames[] = {
12730 (char *) "self", NULL
12731 };
12732
12733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12735 if (SWIG_arg_fail(1)) SWIG_fail;
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (bool)(arg1)->CanDragRowSize();
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxGrid *arg1 = (wxGrid *) 0 ;
12755 bool arg2 = (bool) true ;
12756 PyObject * obj0 = 0 ;
12757 PyObject * obj1 = 0 ;
12758 char *kwnames[] = {
12759 (char *) "self",(char *) "enable", NULL
12760 };
12761
12762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12764 if (SWIG_arg_fail(1)) SWIG_fail;
12765 if (obj1) {
12766 {
12767 arg2 = (bool)(SWIG_As_bool(obj1));
12768 if (SWIG_arg_fail(2)) SWIG_fail;
12769 }
12770 }
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 (arg1)->EnableDragColSize(arg2);
12774
12775 wxPyEndAllowThreads(__tstate);
12776 if (PyErr_Occurred()) SWIG_fail;
12777 }
12778 Py_INCREF(Py_None); resultobj = Py_None;
12779 return resultobj;
12780 fail:
12781 return NULL;
12782 }
12783
12784
12785 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12786 PyObject *resultobj;
12787 wxGrid *arg1 = (wxGrid *) 0 ;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 (arg1)->DisableDragColSize();
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 Py_INCREF(Py_None); resultobj = Py_None;
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxGrid *arg1 = (wxGrid *) 0 ;
12813 bool result;
12814 PyObject * obj0 = 0 ;
12815 char *kwnames[] = {
12816 (char *) "self", NULL
12817 };
12818
12819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
12820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12821 if (SWIG_arg_fail(1)) SWIG_fail;
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 result = (bool)(arg1)->CanDragColSize();
12825
12826 wxPyEndAllowThreads(__tstate);
12827 if (PyErr_Occurred()) SWIG_fail;
12828 }
12829 {
12830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12831 }
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj;
12840 wxGrid *arg1 = (wxGrid *) 0 ;
12841 bool arg2 = (bool) true ;
12842 PyObject * obj0 = 0 ;
12843 PyObject * obj1 = 0 ;
12844 char *kwnames[] = {
12845 (char *) "self",(char *) "enable", NULL
12846 };
12847
12848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
12849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12850 if (SWIG_arg_fail(1)) SWIG_fail;
12851 if (obj1) {
12852 {
12853 arg2 = (bool)(SWIG_As_bool(obj1));
12854 if (SWIG_arg_fail(2)) SWIG_fail;
12855 }
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->EnableDragGridSize(arg2);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxGrid *arg1 = (wxGrid *) 0 ;
12874 PyObject * obj0 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 PyThreadState* __tstate = wxPyBeginAllowThreads();
12884 (arg1)->DisableDragGridSize();
12885
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 Py_INCREF(Py_None); resultobj = Py_None;
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj;
12898 wxGrid *arg1 = (wxGrid *) 0 ;
12899 bool result;
12900 PyObject * obj0 = 0 ;
12901 char *kwnames[] = {
12902 (char *) "self", NULL
12903 };
12904
12905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
12906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12907 if (SWIG_arg_fail(1)) SWIG_fail;
12908 {
12909 PyThreadState* __tstate = wxPyBeginAllowThreads();
12910 result = (bool)(arg1)->CanDragGridSize();
12911
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 {
12916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12917 }
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12925 PyObject *resultobj;
12926 wxGrid *arg1 = (wxGrid *) 0 ;
12927 bool arg2 = (bool) true ;
12928 PyObject * obj0 = 0 ;
12929 PyObject * obj1 = 0 ;
12930 char *kwnames[] = {
12931 (char *) "self",(char *) "enable", NULL
12932 };
12933
12934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
12935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12936 if (SWIG_arg_fail(1)) SWIG_fail;
12937 if (obj1) {
12938 {
12939 arg2 = (bool)(SWIG_As_bool(obj1));
12940 if (SWIG_arg_fail(2)) SWIG_fail;
12941 }
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 (arg1)->EnableDragCell(arg2);
12946
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 Py_INCREF(Py_None); resultobj = Py_None;
12951 return resultobj;
12952 fail:
12953 return NULL;
12954 }
12955
12956
12957 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12958 PyObject *resultobj;
12959 wxGrid *arg1 = (wxGrid *) 0 ;
12960 PyObject * obj0 = 0 ;
12961 char *kwnames[] = {
12962 (char *) "self", NULL
12963 };
12964
12965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
12966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12967 if (SWIG_arg_fail(1)) SWIG_fail;
12968 {
12969 PyThreadState* __tstate = wxPyBeginAllowThreads();
12970 (arg1)->DisableDragCell();
12971
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 Py_INCREF(Py_None); resultobj = Py_None;
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj;
12984 wxGrid *arg1 = (wxGrid *) 0 ;
12985 bool result;
12986 PyObject * obj0 = 0 ;
12987 char *kwnames[] = {
12988 (char *) "self", NULL
12989 };
12990
12991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
12992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12993 if (SWIG_arg_fail(1)) SWIG_fail;
12994 {
12995 PyThreadState* __tstate = wxPyBeginAllowThreads();
12996 result = (bool)(arg1)->CanDragCell();
12997
12998 wxPyEndAllowThreads(__tstate);
12999 if (PyErr_Occurred()) SWIG_fail;
13000 }
13001 {
13002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13003 }
13004 return resultobj;
13005 fail:
13006 return NULL;
13007 }
13008
13009
13010 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj;
13012 wxGrid *arg1 = (wxGrid *) 0 ;
13013 int arg2 ;
13014 int arg3 ;
13015 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 PyObject * obj2 = 0 ;
13019 PyObject * obj3 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 arg2 = (int)(SWIG_As_int(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 {
13032 arg3 = (int)(SWIG_As_int(obj2));
13033 if (SWIG_arg_fail(3)) SWIG_fail;
13034 }
13035 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13036 if (SWIG_arg_fail(4)) SWIG_fail;
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 (arg1)->SetAttr(arg2,arg3,arg4);
13040
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 Py_INCREF(Py_None); resultobj = Py_None;
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxGrid *arg1 = (wxGrid *) 0 ;
13054 int arg2 ;
13055 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13056 PyObject * obj0 = 0 ;
13057 PyObject * obj1 = 0 ;
13058 PyObject * obj2 = 0 ;
13059 char *kwnames[] = {
13060 (char *) "self",(char *) "row",(char *) "attr", NULL
13061 };
13062
13063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13065 if (SWIG_arg_fail(1)) SWIG_fail;
13066 {
13067 arg2 = (int)(SWIG_As_int(obj1));
13068 if (SWIG_arg_fail(2)) SWIG_fail;
13069 }
13070 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13071 if (SWIG_arg_fail(3)) SWIG_fail;
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 (arg1)->SetRowAttr(arg2,arg3);
13075
13076 wxPyEndAllowThreads(__tstate);
13077 if (PyErr_Occurred()) SWIG_fail;
13078 }
13079 Py_INCREF(Py_None); resultobj = Py_None;
13080 return resultobj;
13081 fail:
13082 return NULL;
13083 }
13084
13085
13086 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13087 PyObject *resultobj;
13088 wxGrid *arg1 = (wxGrid *) 0 ;
13089 int arg2 ;
13090 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13091 PyObject * obj0 = 0 ;
13092 PyObject * obj1 = 0 ;
13093 PyObject * obj2 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "col",(char *) "attr", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 {
13102 arg2 = (int)(SWIG_As_int(obj1));
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 }
13105 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13106 if (SWIG_arg_fail(3)) SWIG_fail;
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 (arg1)->SetColAttr(arg2,arg3);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 Py_INCREF(Py_None); resultobj = Py_None;
13115 return resultobj;
13116 fail:
13117 return NULL;
13118 }
13119
13120
13121 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj;
13123 wxGrid *arg1 = (wxGrid *) 0 ;
13124 int arg2 ;
13125 int arg3 ;
13126 wxGridCellAttr *result;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 PyObject * obj2 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "row",(char *) "col", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 arg2 = (int)(SWIG_As_int(obj1));
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 }
13141 {
13142 arg3 = (int)(SWIG_As_int(obj2));
13143 if (SWIG_arg_fail(3)) SWIG_fail;
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 {
13153 resultobj = wxPyMake_wxGridCellAttr(result, 0);
13154 }
13155 return resultobj;
13156 fail:
13157 return NULL;
13158 }
13159
13160
13161 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13162 PyObject *resultobj;
13163 wxGrid *arg1 = (wxGrid *) 0 ;
13164 int arg2 ;
13165 PyObject * obj0 = 0 ;
13166 PyObject * obj1 = 0 ;
13167 char *kwnames[] = {
13168 (char *) "self",(char *) "col", NULL
13169 };
13170
13171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13173 if (SWIG_arg_fail(1)) SWIG_fail;
13174 {
13175 arg2 = (int)(SWIG_As_int(obj1));
13176 if (SWIG_arg_fail(2)) SWIG_fail;
13177 }
13178 {
13179 PyThreadState* __tstate = wxPyBeginAllowThreads();
13180 (arg1)->SetColFormatBool(arg2);
13181
13182 wxPyEndAllowThreads(__tstate);
13183 if (PyErr_Occurred()) SWIG_fail;
13184 }
13185 Py_INCREF(Py_None); resultobj = Py_None;
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj;
13194 wxGrid *arg1 = (wxGrid *) 0 ;
13195 int arg2 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 char *kwnames[] = {
13199 (char *) "self",(char *) "col", NULL
13200 };
13201
13202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13204 if (SWIG_arg_fail(1)) SWIG_fail;
13205 {
13206 arg2 = (int)(SWIG_As_int(obj1));
13207 if (SWIG_arg_fail(2)) SWIG_fail;
13208 }
13209 {
13210 PyThreadState* __tstate = wxPyBeginAllowThreads();
13211 (arg1)->SetColFormatNumber(arg2);
13212
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 Py_INCREF(Py_None); resultobj = Py_None;
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj;
13225 wxGrid *arg1 = (wxGrid *) 0 ;
13226 int arg2 ;
13227 int arg3 = (int) -1 ;
13228 int arg4 = (int) -1 ;
13229 PyObject * obj0 = 0 ;
13230 PyObject * obj1 = 0 ;
13231 PyObject * obj2 = 0 ;
13232 PyObject * obj3 = 0 ;
13233 char *kwnames[] = {
13234 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13235 };
13236
13237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13239 if (SWIG_arg_fail(1)) SWIG_fail;
13240 {
13241 arg2 = (int)(SWIG_As_int(obj1));
13242 if (SWIG_arg_fail(2)) SWIG_fail;
13243 }
13244 if (obj2) {
13245 {
13246 arg3 = (int)(SWIG_As_int(obj2));
13247 if (SWIG_arg_fail(3)) SWIG_fail;
13248 }
13249 }
13250 if (obj3) {
13251 {
13252 arg4 = (int)(SWIG_As_int(obj3));
13253 if (SWIG_arg_fail(4)) SWIG_fail;
13254 }
13255 }
13256 {
13257 PyThreadState* __tstate = wxPyBeginAllowThreads();
13258 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13259
13260 wxPyEndAllowThreads(__tstate);
13261 if (PyErr_Occurred()) SWIG_fail;
13262 }
13263 Py_INCREF(Py_None); resultobj = Py_None;
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13271 PyObject *resultobj;
13272 wxGrid *arg1 = (wxGrid *) 0 ;
13273 int arg2 ;
13274 wxString *arg3 = 0 ;
13275 bool temp3 = false ;
13276 PyObject * obj0 = 0 ;
13277 PyObject * obj1 = 0 ;
13278 PyObject * obj2 = 0 ;
13279 char *kwnames[] = {
13280 (char *) "self",(char *) "col",(char *) "typeName", NULL
13281 };
13282
13283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13285 if (SWIG_arg_fail(1)) SWIG_fail;
13286 {
13287 arg2 = (int)(SWIG_As_int(obj1));
13288 if (SWIG_arg_fail(2)) SWIG_fail;
13289 }
13290 {
13291 arg3 = wxString_in_helper(obj2);
13292 if (arg3 == NULL) SWIG_fail;
13293 temp3 = true;
13294 }
13295 {
13296 PyThreadState* __tstate = wxPyBeginAllowThreads();
13297 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13298
13299 wxPyEndAllowThreads(__tstate);
13300 if (PyErr_Occurred()) SWIG_fail;
13301 }
13302 Py_INCREF(Py_None); resultobj = Py_None;
13303 {
13304 if (temp3)
13305 delete arg3;
13306 }
13307 return resultobj;
13308 fail:
13309 {
13310 if (temp3)
13311 delete arg3;
13312 }
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj;
13319 wxGrid *arg1 = (wxGrid *) 0 ;
13320 bool arg2 = (bool) true ;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 char *kwnames[] = {
13324 (char *) "self",(char *) "enable", NULL
13325 };
13326
13327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13329 if (SWIG_arg_fail(1)) SWIG_fail;
13330 if (obj1) {
13331 {
13332 arg2 = (bool)(SWIG_As_bool(obj1));
13333 if (SWIG_arg_fail(2)) SWIG_fail;
13334 }
13335 }
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 (arg1)->EnableGridLines(arg2);
13339
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 Py_INCREF(Py_None); resultobj = Py_None;
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 static PyObject *_wrap_Grid_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13351 PyObject *resultobj;
13352 wxGrid *arg1 = (wxGrid *) 0 ;
13353 bool result;
13354 PyObject * obj0 = 0 ;
13355 char *kwnames[] = {
13356 (char *) "self", NULL
13357 };
13358
13359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13361 if (SWIG_arg_fail(1)) SWIG_fail;
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (bool)(arg1)->GridLinesEnabled();
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13371 }
13372 return resultobj;
13373 fail:
13374 return NULL;
13375 }
13376
13377
13378 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13379 PyObject *resultobj;
13380 wxGrid *arg1 = (wxGrid *) 0 ;
13381 int result;
13382 PyObject * obj0 = 0 ;
13383 char *kwnames[] = {
13384 (char *) "self", NULL
13385 };
13386
13387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13389 if (SWIG_arg_fail(1)) SWIG_fail;
13390 {
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (int)(arg1)->GetDefaultRowSize();
13393
13394 wxPyEndAllowThreads(__tstate);
13395 if (PyErr_Occurred()) SWIG_fail;
13396 }
13397 {
13398 resultobj = SWIG_From_int((int)(result));
13399 }
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj;
13408 wxGrid *arg1 = (wxGrid *) 0 ;
13409 int arg2 ;
13410 int result;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 char *kwnames[] = {
13414 (char *) "self",(char *) "row", NULL
13415 };
13416
13417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13419 if (SWIG_arg_fail(1)) SWIG_fail;
13420 {
13421 arg2 = (int)(SWIG_As_int(obj1));
13422 if (SWIG_arg_fail(2)) SWIG_fail;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = (int)(arg1)->GetRowSize(arg2);
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432 resultobj = SWIG_From_int((int)(result));
13433 }
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj;
13442 wxGrid *arg1 = (wxGrid *) 0 ;
13443 int result;
13444 PyObject * obj0 = 0 ;
13445 char *kwnames[] = {
13446 (char *) "self", NULL
13447 };
13448
13449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13451 if (SWIG_arg_fail(1)) SWIG_fail;
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 result = (int)(arg1)->GetDefaultColSize();
13455
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 resultobj = SWIG_From_int((int)(result));
13461 }
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13469 PyObject *resultobj;
13470 wxGrid *arg1 = (wxGrid *) 0 ;
13471 int arg2 ;
13472 int result;
13473 PyObject * obj0 = 0 ;
13474 PyObject * obj1 = 0 ;
13475 char *kwnames[] = {
13476 (char *) "self",(char *) "col", NULL
13477 };
13478
13479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13481 if (SWIG_arg_fail(1)) SWIG_fail;
13482 {
13483 arg2 = (int)(SWIG_As_int(obj1));
13484 if (SWIG_arg_fail(2)) SWIG_fail;
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = (int)(arg1)->GetColSize(arg2);
13489
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 {
13494 resultobj = SWIG_From_int((int)(result));
13495 }
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj;
13504 wxGrid *arg1 = (wxGrid *) 0 ;
13505 wxColour result;
13506 PyObject * obj0 = 0 ;
13507 char *kwnames[] = {
13508 (char *) "self", NULL
13509 };
13510
13511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13513 if (SWIG_arg_fail(1)) SWIG_fail;
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (arg1)->GetDefaultCellBackgroundColour();
13517
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 {
13522 wxColour * resultptr;
13523 resultptr = new wxColour((wxColour &)(result));
13524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13525 }
13526 return resultobj;
13527 fail:
13528 return NULL;
13529 }
13530
13531
13532 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13533 PyObject *resultobj;
13534 wxGrid *arg1 = (wxGrid *) 0 ;
13535 int arg2 ;
13536 int arg3 ;
13537 wxColour result;
13538 PyObject * obj0 = 0 ;
13539 PyObject * obj1 = 0 ;
13540 PyObject * obj2 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "row",(char *) "col", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 {
13549 arg2 = (int)(SWIG_As_int(obj1));
13550 if (SWIG_arg_fail(2)) SWIG_fail;
13551 }
13552 {
13553 arg3 = (int)(SWIG_As_int(obj2));
13554 if (SWIG_arg_fail(3)) SWIG_fail;
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13559
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 {
13564 wxColour * resultptr;
13565 resultptr = new wxColour((wxColour &)(result));
13566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13567 }
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj;
13576 wxGrid *arg1 = (wxGrid *) 0 ;
13577 wxColour result;
13578 PyObject * obj0 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "self", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13585 if (SWIG_arg_fail(1)) SWIG_fail;
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 result = (arg1)->GetDefaultCellTextColour();
13589
13590 wxPyEndAllowThreads(__tstate);
13591 if (PyErr_Occurred()) SWIG_fail;
13592 }
13593 {
13594 wxColour * resultptr;
13595 resultptr = new wxColour((wxColour &)(result));
13596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13597 }
13598 return resultobj;
13599 fail:
13600 return NULL;
13601 }
13602
13603
13604 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj;
13606 wxGrid *arg1 = (wxGrid *) 0 ;
13607 int arg2 ;
13608 int arg3 ;
13609 wxColour result;
13610 PyObject * obj0 = 0 ;
13611 PyObject * obj1 = 0 ;
13612 PyObject * obj2 = 0 ;
13613 char *kwnames[] = {
13614 (char *) "self",(char *) "row",(char *) "col", NULL
13615 };
13616
13617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13619 if (SWIG_arg_fail(1)) SWIG_fail;
13620 {
13621 arg2 = (int)(SWIG_As_int(obj1));
13622 if (SWIG_arg_fail(2)) SWIG_fail;
13623 }
13624 {
13625 arg3 = (int)(SWIG_As_int(obj2));
13626 if (SWIG_arg_fail(3)) SWIG_fail;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (arg1)->GetCellTextColour(arg2,arg3);
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 {
13636 wxColour * resultptr;
13637 resultptr = new wxColour((wxColour &)(result));
13638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13639 }
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj;
13648 wxGrid *arg1 = (wxGrid *) 0 ;
13649 wxFont result;
13650 PyObject * obj0 = 0 ;
13651 char *kwnames[] = {
13652 (char *) "self", NULL
13653 };
13654
13655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13657 if (SWIG_arg_fail(1)) SWIG_fail;
13658 {
13659 PyThreadState* __tstate = wxPyBeginAllowThreads();
13660 result = (arg1)->GetDefaultCellFont();
13661
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 {
13666 wxFont * resultptr;
13667 resultptr = new wxFont((wxFont &)(result));
13668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13669 }
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13677 PyObject *resultobj;
13678 wxGrid *arg1 = (wxGrid *) 0 ;
13679 int arg2 ;
13680 int arg3 ;
13681 wxFont result;
13682 PyObject * obj0 = 0 ;
13683 PyObject * obj1 = 0 ;
13684 PyObject * obj2 = 0 ;
13685 char *kwnames[] = {
13686 (char *) "self",(char *) "row",(char *) "col", NULL
13687 };
13688
13689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13691 if (SWIG_arg_fail(1)) SWIG_fail;
13692 {
13693 arg2 = (int)(SWIG_As_int(obj1));
13694 if (SWIG_arg_fail(2)) SWIG_fail;
13695 }
13696 {
13697 arg3 = (int)(SWIG_As_int(obj2));
13698 if (SWIG_arg_fail(3)) SWIG_fail;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 result = (arg1)->GetCellFont(arg2,arg3);
13703
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 {
13708 wxFont * resultptr;
13709 resultptr = new wxFont((wxFont &)(result));
13710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13711 }
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxGrid *arg1 = (wxGrid *) 0 ;
13721 int *arg2 = (int *) 0 ;
13722 int *arg3 = (int *) 0 ;
13723 int temp2 ;
13724 int res2 = 0 ;
13725 int temp3 ;
13726 int res3 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self", NULL
13730 };
13731
13732 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13733 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13736 if (SWIG_arg_fail(1)) SWIG_fail;
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13740
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 Py_INCREF(Py_None); resultobj = Py_None;
13745 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13746 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13747 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13748 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13756 PyObject *resultobj;
13757 wxGrid *arg1 = (wxGrid *) 0 ;
13758 int arg2 ;
13759 int arg3 ;
13760 int *arg4 = (int *) 0 ;
13761 int *arg5 = (int *) 0 ;
13762 int temp4 ;
13763 int res4 = 0 ;
13764 int temp5 ;
13765 int res5 = 0 ;
13766 PyObject * obj0 = 0 ;
13767 PyObject * obj1 = 0 ;
13768 PyObject * obj2 = 0 ;
13769 char *kwnames[] = {
13770 (char *) "self",(char *) "row",(char *) "col", NULL
13771 };
13772
13773 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13774 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
13776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13777 if (SWIG_arg_fail(1)) SWIG_fail;
13778 {
13779 arg2 = (int)(SWIG_As_int(obj1));
13780 if (SWIG_arg_fail(2)) SWIG_fail;
13781 }
13782 {
13783 arg3 = (int)(SWIG_As_int(obj2));
13784 if (SWIG_arg_fail(3)) SWIG_fail;
13785 }
13786 {
13787 PyThreadState* __tstate = wxPyBeginAllowThreads();
13788 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13789
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 Py_INCREF(Py_None); resultobj = Py_None;
13794 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13795 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13796 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13797 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13798 return resultobj;
13799 fail:
13800 return NULL;
13801 }
13802
13803
13804 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj;
13806 wxGrid *arg1 = (wxGrid *) 0 ;
13807 bool result;
13808 PyObject * obj0 = 0 ;
13809 char *kwnames[] = {
13810 (char *) "self", NULL
13811 };
13812
13813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",kwnames,&obj0)) goto fail;
13814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13815 if (SWIG_arg_fail(1)) SWIG_fail;
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 result = (bool)(arg1)->GetDefaultCellOverflow();
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 {
13824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13825 }
13826 return resultobj;
13827 fail:
13828 return NULL;
13829 }
13830
13831
13832 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13833 PyObject *resultobj;
13834 wxGrid *arg1 = (wxGrid *) 0 ;
13835 int arg2 ;
13836 int arg3 ;
13837 bool result;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char *kwnames[] = {
13842 (char *) "self",(char *) "row",(char *) "col", NULL
13843 };
13844
13845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
13846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13847 if (SWIG_arg_fail(1)) SWIG_fail;
13848 {
13849 arg2 = (int)(SWIG_As_int(obj1));
13850 if (SWIG_arg_fail(2)) SWIG_fail;
13851 }
13852 {
13853 arg3 = (int)(SWIG_As_int(obj2));
13854 if (SWIG_arg_fail(3)) SWIG_fail;
13855 }
13856 {
13857 PyThreadState* __tstate = wxPyBeginAllowThreads();
13858 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
13859
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 {
13864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13865 }
13866 return resultobj;
13867 fail:
13868 return NULL;
13869 }
13870
13871
13872 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
13873 PyObject *resultobj;
13874 wxGrid *arg1 = (wxGrid *) 0 ;
13875 int arg2 ;
13876 int arg3 ;
13877 int *arg4 = (int *) 0 ;
13878 int *arg5 = (int *) 0 ;
13879 int temp4 ;
13880 int res4 = 0 ;
13881 int temp5 ;
13882 int res5 = 0 ;
13883 PyObject * obj0 = 0 ;
13884 PyObject * obj1 = 0 ;
13885 PyObject * obj2 = 0 ;
13886 char *kwnames[] = {
13887 (char *) "self",(char *) "row",(char *) "col", NULL
13888 };
13889
13890 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13891 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13894 if (SWIG_arg_fail(1)) SWIG_fail;
13895 {
13896 arg2 = (int)(SWIG_As_int(obj1));
13897 if (SWIG_arg_fail(2)) SWIG_fail;
13898 }
13899 {
13900 arg3 = (int)(SWIG_As_int(obj2));
13901 if (SWIG_arg_fail(3)) SWIG_fail;
13902 }
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 Py_INCREF(Py_None); resultobj = Py_None;
13911 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13912 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13913 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13914 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj;
13923 wxGrid *arg1 = (wxGrid *) 0 ;
13924 int arg2 ;
13925 bool arg3 = (bool) false ;
13926 PyObject * obj0 = 0 ;
13927 PyObject * obj1 = 0 ;
13928 PyObject * obj2 = 0 ;
13929 char *kwnames[] = {
13930 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
13931 };
13932
13933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13935 if (SWIG_arg_fail(1)) SWIG_fail;
13936 {
13937 arg2 = (int)(SWIG_As_int(obj1));
13938 if (SWIG_arg_fail(2)) SWIG_fail;
13939 }
13940 if (obj2) {
13941 {
13942 arg3 = (bool)(SWIG_As_bool(obj2));
13943 if (SWIG_arg_fail(3)) SWIG_fail;
13944 }
13945 }
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 (arg1)->SetDefaultRowSize(arg2,arg3);
13949
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 Py_INCREF(Py_None); resultobj = Py_None;
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj;
13962 wxGrid *arg1 = (wxGrid *) 0 ;
13963 int arg2 ;
13964 int arg3 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 char *kwnames[] = {
13969 (char *) "self",(char *) "row",(char *) "height", NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13974 if (SWIG_arg_fail(1)) SWIG_fail;
13975 {
13976 arg2 = (int)(SWIG_As_int(obj1));
13977 if (SWIG_arg_fail(2)) SWIG_fail;
13978 }
13979 {
13980 arg3 = (int)(SWIG_As_int(obj2));
13981 if (SWIG_arg_fail(3)) SWIG_fail;
13982 }
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 (arg1)->SetRowSize(arg2,arg3);
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 Py_INCREF(Py_None); resultobj = Py_None;
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxGrid *arg1 = (wxGrid *) 0 ;
14000 int arg2 ;
14001 bool arg3 = (bool) false ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 PyObject * obj2 = 0 ;
14005 char *kwnames[] = {
14006 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
14007 };
14008
14009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14011 if (SWIG_arg_fail(1)) SWIG_fail;
14012 {
14013 arg2 = (int)(SWIG_As_int(obj1));
14014 if (SWIG_arg_fail(2)) SWIG_fail;
14015 }
14016 if (obj2) {
14017 {
14018 arg3 = (bool)(SWIG_As_bool(obj2));
14019 if (SWIG_arg_fail(3)) SWIG_fail;
14020 }
14021 }
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 (arg1)->SetDefaultColSize(arg2,arg3);
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 Py_INCREF(Py_None); resultobj = Py_None;
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxGrid *arg1 = (wxGrid *) 0 ;
14039 int arg2 ;
14040 int arg3 ;
14041 PyObject * obj0 = 0 ;
14042 PyObject * obj1 = 0 ;
14043 PyObject * obj2 = 0 ;
14044 char *kwnames[] = {
14045 (char *) "self",(char *) "col",(char *) "width", NULL
14046 };
14047
14048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14050 if (SWIG_arg_fail(1)) SWIG_fail;
14051 {
14052 arg2 = (int)(SWIG_As_int(obj1));
14053 if (SWIG_arg_fail(2)) SWIG_fail;
14054 }
14055 {
14056 arg3 = (int)(SWIG_As_int(obj2));
14057 if (SWIG_arg_fail(3)) SWIG_fail;
14058 }
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 (arg1)->SetColSize(arg2,arg3);
14062
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 Py_INCREF(Py_None); resultobj = Py_None;
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj;
14075 wxGrid *arg1 = (wxGrid *) 0 ;
14076 int arg2 ;
14077 bool arg3 = (bool) true ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 PyObject * obj2 = 0 ;
14081 char *kwnames[] = {
14082 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14083 };
14084
14085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 {
14089 arg2 = (int)(SWIG_As_int(obj1));
14090 if (SWIG_arg_fail(2)) SWIG_fail;
14091 }
14092 if (obj2) {
14093 {
14094 arg3 = (bool)(SWIG_As_bool(obj2));
14095 if (SWIG_arg_fail(3)) SWIG_fail;
14096 }
14097 }
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 (arg1)->AutoSizeColumn(arg2,arg3);
14101
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 Py_INCREF(Py_None); resultobj = Py_None;
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj;
14114 wxGrid *arg1 = (wxGrid *) 0 ;
14115 int arg2 ;
14116 bool arg3 = (bool) true ;
14117 PyObject * obj0 = 0 ;
14118 PyObject * obj1 = 0 ;
14119 PyObject * obj2 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 arg2 = (int)(SWIG_As_int(obj1));
14129 if (SWIG_arg_fail(2)) SWIG_fail;
14130 }
14131 if (obj2) {
14132 {
14133 arg3 = (bool)(SWIG_As_bool(obj2));
14134 if (SWIG_arg_fail(3)) SWIG_fail;
14135 }
14136 }
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 (arg1)->AutoSizeRow(arg2,arg3);
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 Py_INCREF(Py_None); resultobj = Py_None;
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14152 PyObject *resultobj;
14153 wxGrid *arg1 = (wxGrid *) 0 ;
14154 bool arg2 = (bool) true ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self",(char *) "setAsMin", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 if (obj1) {
14165 {
14166 arg2 = (bool)(SWIG_As_bool(obj1));
14167 if (SWIG_arg_fail(2)) SWIG_fail;
14168 }
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 (arg1)->AutoSizeColumns(arg2);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 Py_INCREF(Py_None); resultobj = Py_None;
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxGrid *arg1 = (wxGrid *) 0 ;
14187 bool arg2 = (bool) true ;
14188 PyObject * obj0 = 0 ;
14189 PyObject * obj1 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self",(char *) "setAsMin", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 if (obj1) {
14198 {
14199 arg2 = (bool)(SWIG_As_bool(obj1));
14200 if (SWIG_arg_fail(2)) SWIG_fail;
14201 }
14202 }
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 (arg1)->AutoSizeRows(arg2);
14206
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 Py_INCREF(Py_None); resultobj = Py_None;
14211 return resultobj;
14212 fail:
14213 return NULL;
14214 }
14215
14216
14217 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14218 PyObject *resultobj;
14219 wxGrid *arg1 = (wxGrid *) 0 ;
14220 PyObject * obj0 = 0 ;
14221 char *kwnames[] = {
14222 (char *) "self", NULL
14223 };
14224
14225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) goto fail;
14226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14227 if (SWIG_arg_fail(1)) SWIG_fail;
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 (arg1)->AutoSize();
14231
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 Py_INCREF(Py_None); resultobj = Py_None;
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxGrid *arg1 = (wxGrid *) 0 ;
14245 int arg2 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self",(char *) "row", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 {
14256 arg2 = (int)(SWIG_As_int(obj1));
14257 if (SWIG_arg_fail(2)) SWIG_fail;
14258 }
14259 {
14260 PyThreadState* __tstate = wxPyBeginAllowThreads();
14261 (arg1)->AutoSizeRowLabelSize(arg2);
14262
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 Py_INCREF(Py_None); resultobj = Py_None;
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxGrid *arg1 = (wxGrid *) 0 ;
14276 int arg2 ;
14277 PyObject * obj0 = 0 ;
14278 PyObject * obj1 = 0 ;
14279 char *kwnames[] = {
14280 (char *) "self",(char *) "col", NULL
14281 };
14282
14283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14285 if (SWIG_arg_fail(1)) SWIG_fail;
14286 {
14287 arg2 = (int)(SWIG_As_int(obj1));
14288 if (SWIG_arg_fail(2)) SWIG_fail;
14289 }
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 (arg1)->AutoSizeColLabelSize(arg2);
14293
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 Py_INCREF(Py_None); resultobj = Py_None;
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14305 PyObject *resultobj;
14306 wxGrid *arg1 = (wxGrid *) 0 ;
14307 int arg2 ;
14308 int arg3 ;
14309 PyObject * obj0 = 0 ;
14310 PyObject * obj1 = 0 ;
14311 PyObject * obj2 = 0 ;
14312 char *kwnames[] = {
14313 (char *) "self",(char *) "col",(char *) "width", NULL
14314 };
14315
14316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 {
14320 arg2 = (int)(SWIG_As_int(obj1));
14321 if (SWIG_arg_fail(2)) SWIG_fail;
14322 }
14323 {
14324 arg3 = (int)(SWIG_As_int(obj2));
14325 if (SWIG_arg_fail(3)) SWIG_fail;
14326 }
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 (arg1)->SetColMinimalWidth(arg2,arg3);
14330
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 Py_INCREF(Py_None); resultobj = Py_None;
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxGrid *arg1 = (wxGrid *) 0 ;
14344 int arg2 ;
14345 int arg3 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 PyObject * obj2 = 0 ;
14349 char *kwnames[] = {
14350 (char *) "self",(char *) "row",(char *) "width", NULL
14351 };
14352
14353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14355 if (SWIG_arg_fail(1)) SWIG_fail;
14356 {
14357 arg2 = (int)(SWIG_As_int(obj1));
14358 if (SWIG_arg_fail(2)) SWIG_fail;
14359 }
14360 {
14361 arg3 = (int)(SWIG_As_int(obj2));
14362 if (SWIG_arg_fail(3)) SWIG_fail;
14363 }
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 (arg1)->SetRowMinimalHeight(arg2,arg3);
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 Py_INCREF(Py_None); resultobj = Py_None;
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj;
14380 wxGrid *arg1 = (wxGrid *) 0 ;
14381 int arg2 ;
14382 PyObject * obj0 = 0 ;
14383 PyObject * obj1 = 0 ;
14384 char *kwnames[] = {
14385 (char *) "self",(char *) "width", NULL
14386 };
14387
14388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14390 if (SWIG_arg_fail(1)) SWIG_fail;
14391 {
14392 arg2 = (int)(SWIG_As_int(obj1));
14393 if (SWIG_arg_fail(2)) SWIG_fail;
14394 }
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 (arg1)->SetColMinimalAcceptableWidth(arg2);
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 Py_INCREF(Py_None); resultobj = Py_None;
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj;
14411 wxGrid *arg1 = (wxGrid *) 0 ;
14412 int arg2 ;
14413 PyObject * obj0 = 0 ;
14414 PyObject * obj1 = 0 ;
14415 char *kwnames[] = {
14416 (char *) "self",(char *) "width", NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14421 if (SWIG_arg_fail(1)) SWIG_fail;
14422 {
14423 arg2 = (int)(SWIG_As_int(obj1));
14424 if (SWIG_arg_fail(2)) SWIG_fail;
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14429
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 Py_INCREF(Py_None); resultobj = Py_None;
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj;
14442 wxGrid *arg1 = (wxGrid *) 0 ;
14443 int result;
14444 PyObject * obj0 = 0 ;
14445 char *kwnames[] = {
14446 (char *) "self", NULL
14447 };
14448
14449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 {
14460 resultobj = SWIG_From_int((int)(result));
14461 }
14462 return resultobj;
14463 fail:
14464 return NULL;
14465 }
14466
14467
14468 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14469 PyObject *resultobj;
14470 wxGrid *arg1 = (wxGrid *) 0 ;
14471 int result;
14472 PyObject * obj0 = 0 ;
14473 char *kwnames[] = {
14474 (char *) "self", NULL
14475 };
14476
14477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 {
14488 resultobj = SWIG_From_int((int)(result));
14489 }
14490 return resultobj;
14491 fail:
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxGrid *arg1 = (wxGrid *) 0 ;
14499 wxColour *arg2 = 0 ;
14500 wxColour temp2 ;
14501 PyObject * obj0 = 0 ;
14502 PyObject * obj1 = 0 ;
14503 char *kwnames[] = {
14504 (char *) "self","arg2", NULL
14505 };
14506
14507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14509 if (SWIG_arg_fail(1)) SWIG_fail;
14510 {
14511 arg2 = &temp2;
14512 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 Py_INCREF(Py_None); resultobj = Py_None;
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxGrid *arg1 = (wxGrid *) 0 ;
14531 int arg2 ;
14532 int arg3 ;
14533 wxColour *arg4 = 0 ;
14534 wxColour temp4 ;
14535 PyObject * obj0 = 0 ;
14536 PyObject * obj1 = 0 ;
14537 PyObject * obj2 = 0 ;
14538 PyObject * obj3 = 0 ;
14539 char *kwnames[] = {
14540 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14541 };
14542
14543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14545 if (SWIG_arg_fail(1)) SWIG_fail;
14546 {
14547 arg2 = (int)(SWIG_As_int(obj1));
14548 if (SWIG_arg_fail(2)) SWIG_fail;
14549 }
14550 {
14551 arg3 = (int)(SWIG_As_int(obj2));
14552 if (SWIG_arg_fail(3)) SWIG_fail;
14553 }
14554 {
14555 arg4 = &temp4;
14556 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14557 }
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 Py_INCREF(Py_None); resultobj = Py_None;
14566 return resultobj;
14567 fail:
14568 return NULL;
14569 }
14570
14571
14572 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj;
14574 wxGrid *arg1 = (wxGrid *) 0 ;
14575 wxColour *arg2 = 0 ;
14576 wxColour temp2 ;
14577 PyObject * obj0 = 0 ;
14578 PyObject * obj1 = 0 ;
14579 char *kwnames[] = {
14580 (char *) "self","arg2", NULL
14581 };
14582
14583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14585 if (SWIG_arg_fail(1)) SWIG_fail;
14586 {
14587 arg2 = &temp2;
14588 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14589 }
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14593
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 Py_INCREF(Py_None); resultobj = Py_None;
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj;
14606 wxGrid *arg1 = (wxGrid *) 0 ;
14607 int arg2 ;
14608 int arg3 ;
14609 wxColour *arg4 = 0 ;
14610 wxColour temp4 ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 PyObject * obj2 = 0 ;
14614 PyObject * obj3 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 arg2 = (int)(SWIG_As_int(obj1));
14624 if (SWIG_arg_fail(2)) SWIG_fail;
14625 }
14626 {
14627 arg3 = (int)(SWIG_As_int(obj2));
14628 if (SWIG_arg_fail(3)) SWIG_fail;
14629 }
14630 {
14631 arg4 = &temp4;
14632 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14633 }
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 Py_INCREF(Py_None); resultobj = Py_None;
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj;
14650 wxGrid *arg1 = (wxGrid *) 0 ;
14651 wxFont *arg2 = 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 char *kwnames[] = {
14655 (char *) "self","arg2", NULL
14656 };
14657
14658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14660 if (SWIG_arg_fail(1)) SWIG_fail;
14661 {
14662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14663 if (SWIG_arg_fail(2)) SWIG_fail;
14664 if (arg2 == NULL) {
14665 SWIG_null_ref("wxFont");
14666 }
14667 if (SWIG_arg_fail(2)) SWIG_fail;
14668 }
14669 {
14670 PyThreadState* __tstate = wxPyBeginAllowThreads();
14671 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14672
14673 wxPyEndAllowThreads(__tstate);
14674 if (PyErr_Occurred()) SWIG_fail;
14675 }
14676 Py_INCREF(Py_None); resultobj = Py_None;
14677 return resultobj;
14678 fail:
14679 return NULL;
14680 }
14681
14682
14683 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14684 PyObject *resultobj;
14685 wxGrid *arg1 = (wxGrid *) 0 ;
14686 int arg2 ;
14687 int arg3 ;
14688 wxFont *arg4 = 0 ;
14689 PyObject * obj0 = 0 ;
14690 PyObject * obj1 = 0 ;
14691 PyObject * obj2 = 0 ;
14692 PyObject * obj3 = 0 ;
14693 char *kwnames[] = {
14694 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14695 };
14696
14697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14699 if (SWIG_arg_fail(1)) SWIG_fail;
14700 {
14701 arg2 = (int)(SWIG_As_int(obj1));
14702 if (SWIG_arg_fail(2)) SWIG_fail;
14703 }
14704 {
14705 arg3 = (int)(SWIG_As_int(obj2));
14706 if (SWIG_arg_fail(3)) SWIG_fail;
14707 }
14708 {
14709 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(4)) SWIG_fail;
14711 if (arg4 == NULL) {
14712 SWIG_null_ref("wxFont");
14713 }
14714 if (SWIG_arg_fail(4)) SWIG_fail;
14715 }
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
14719
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 Py_INCREF(Py_None); resultobj = Py_None;
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 static PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14731 PyObject *resultobj;
14732 wxGrid *arg1 = (wxGrid *) 0 ;
14733 int arg2 ;
14734 int arg3 ;
14735 PyObject * obj0 = 0 ;
14736 PyObject * obj1 = 0 ;
14737 PyObject * obj2 = 0 ;
14738 char *kwnames[] = {
14739 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14740 };
14741
14742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14744 if (SWIG_arg_fail(1)) SWIG_fail;
14745 {
14746 arg2 = (int)(SWIG_As_int(obj1));
14747 if (SWIG_arg_fail(2)) SWIG_fail;
14748 }
14749 {
14750 arg3 = (int)(SWIG_As_int(obj2));
14751 if (SWIG_arg_fail(3)) SWIG_fail;
14752 }
14753 {
14754 PyThreadState* __tstate = wxPyBeginAllowThreads();
14755 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14756
14757 wxPyEndAllowThreads(__tstate);
14758 if (PyErr_Occurred()) SWIG_fail;
14759 }
14760 Py_INCREF(Py_None); resultobj = Py_None;
14761 return resultobj;
14762 fail:
14763 return NULL;
14764 }
14765
14766
14767 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14768 PyObject *resultobj;
14769 wxGrid *arg1 = (wxGrid *) 0 ;
14770 int arg2 ;
14771 int arg3 ;
14772 int arg4 ;
14773 int arg5 ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 PyObject * obj3 = 0 ;
14778 PyObject * obj4 = 0 ;
14779 char *kwnames[] = {
14780 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14781 };
14782
14783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14785 if (SWIG_arg_fail(1)) SWIG_fail;
14786 {
14787 arg2 = (int)(SWIG_As_int(obj1));
14788 if (SWIG_arg_fail(2)) SWIG_fail;
14789 }
14790 {
14791 arg3 = (int)(SWIG_As_int(obj2));
14792 if (SWIG_arg_fail(3)) SWIG_fail;
14793 }
14794 {
14795 arg4 = (int)(SWIG_As_int(obj3));
14796 if (SWIG_arg_fail(4)) SWIG_fail;
14797 }
14798 {
14799 arg5 = (int)(SWIG_As_int(obj4));
14800 if (SWIG_arg_fail(5)) SWIG_fail;
14801 }
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
14805
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 Py_INCREF(Py_None); resultobj = Py_None;
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj;
14818 wxGrid *arg1 = (wxGrid *) 0 ;
14819 bool arg2 ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 char *kwnames[] = {
14823 (char *) "self",(char *) "allow", NULL
14824 };
14825
14826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
14827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14828 if (SWIG_arg_fail(1)) SWIG_fail;
14829 {
14830 arg2 = (bool)(SWIG_As_bool(obj1));
14831 if (SWIG_arg_fail(2)) SWIG_fail;
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 (arg1)->SetDefaultCellOverflow(arg2);
14836
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 Py_INCREF(Py_None); resultobj = Py_None;
14841 return resultobj;
14842 fail:
14843 return NULL;
14844 }
14845
14846
14847 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14848 PyObject *resultobj;
14849 wxGrid *arg1 = (wxGrid *) 0 ;
14850 int arg2 ;
14851 int arg3 ;
14852 bool arg4 ;
14853 PyObject * obj0 = 0 ;
14854 PyObject * obj1 = 0 ;
14855 PyObject * obj2 = 0 ;
14856 PyObject * obj3 = 0 ;
14857 char *kwnames[] = {
14858 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
14859 };
14860
14861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14863 if (SWIG_arg_fail(1)) SWIG_fail;
14864 {
14865 arg2 = (int)(SWIG_As_int(obj1));
14866 if (SWIG_arg_fail(2)) SWIG_fail;
14867 }
14868 {
14869 arg3 = (int)(SWIG_As_int(obj2));
14870 if (SWIG_arg_fail(3)) SWIG_fail;
14871 }
14872 {
14873 arg4 = (bool)(SWIG_As_bool(obj3));
14874 if (SWIG_arg_fail(4)) SWIG_fail;
14875 }
14876 {
14877 PyThreadState* __tstate = wxPyBeginAllowThreads();
14878 (arg1)->SetCellOverflow(arg2,arg3,arg4);
14879
14880 wxPyEndAllowThreads(__tstate);
14881 if (PyErr_Occurred()) SWIG_fail;
14882 }
14883 Py_INCREF(Py_None); resultobj = Py_None;
14884 return resultobj;
14885 fail:
14886 return NULL;
14887 }
14888
14889
14890 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj;
14892 wxGrid *arg1 = (wxGrid *) 0 ;
14893 int arg2 ;
14894 int arg3 ;
14895 int arg4 ;
14896 int arg5 ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 PyObject * obj3 = 0 ;
14901 PyObject * obj4 = 0 ;
14902 char *kwnames[] = {
14903 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
14904 };
14905
14906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14908 if (SWIG_arg_fail(1)) SWIG_fail;
14909 {
14910 arg2 = (int)(SWIG_As_int(obj1));
14911 if (SWIG_arg_fail(2)) SWIG_fail;
14912 }
14913 {
14914 arg3 = (int)(SWIG_As_int(obj2));
14915 if (SWIG_arg_fail(3)) SWIG_fail;
14916 }
14917 {
14918 arg4 = (int)(SWIG_As_int(obj3));
14919 if (SWIG_arg_fail(4)) SWIG_fail;
14920 }
14921 {
14922 arg5 = (int)(SWIG_As_int(obj4));
14923 if (SWIG_arg_fail(5)) SWIG_fail;
14924 }
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
14928
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 Py_INCREF(Py_None); resultobj = Py_None;
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14940 PyObject *resultobj;
14941 wxGrid *arg1 = (wxGrid *) 0 ;
14942 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
14943 PyObject * obj0 = 0 ;
14944 PyObject * obj1 = 0 ;
14945 char *kwnames[] = {
14946 (char *) "self",(char *) "renderer", NULL
14947 };
14948
14949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
14950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14951 if (SWIG_arg_fail(1)) SWIG_fail;
14952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14953 if (SWIG_arg_fail(2)) SWIG_fail;
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 (arg1)->SetDefaultRenderer(arg2);
14957
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 Py_INCREF(Py_None); resultobj = Py_None;
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj;
14970 wxGrid *arg1 = (wxGrid *) 0 ;
14971 int arg2 ;
14972 int arg3 ;
14973 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
14974 PyObject * obj0 = 0 ;
14975 PyObject * obj1 = 0 ;
14976 PyObject * obj2 = 0 ;
14977 PyObject * obj3 = 0 ;
14978 char *kwnames[] = {
14979 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
14980 };
14981
14982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14984 if (SWIG_arg_fail(1)) SWIG_fail;
14985 {
14986 arg2 = (int)(SWIG_As_int(obj1));
14987 if (SWIG_arg_fail(2)) SWIG_fail;
14988 }
14989 {
14990 arg3 = (int)(SWIG_As_int(obj2));
14991 if (SWIG_arg_fail(3)) SWIG_fail;
14992 }
14993 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14994 if (SWIG_arg_fail(4)) SWIG_fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 (arg1)->SetCellRenderer(arg2,arg3,arg4);
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 Py_INCREF(Py_None); resultobj = Py_None;
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj;
15011 wxGrid *arg1 = (wxGrid *) 0 ;
15012 wxGridCellRenderer *result;
15013 PyObject * obj0 = 0 ;
15014 char *kwnames[] = {
15015 (char *) "self", NULL
15016 };
15017
15018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
15019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15020 if (SWIG_arg_fail(1)) SWIG_fail;
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 {
15029 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15030 }
15031 return resultobj;
15032 fail:
15033 return NULL;
15034 }
15035
15036
15037 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15038 PyObject *resultobj;
15039 wxGrid *arg1 = (wxGrid *) 0 ;
15040 int arg2 ;
15041 int arg3 ;
15042 wxGridCellRenderer *result;
15043 PyObject * obj0 = 0 ;
15044 PyObject * obj1 = 0 ;
15045 PyObject * obj2 = 0 ;
15046 char *kwnames[] = {
15047 (char *) "self",(char *) "row",(char *) "col", NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15052 if (SWIG_arg_fail(1)) SWIG_fail;
15053 {
15054 arg2 = (int)(SWIG_As_int(obj1));
15055 if (SWIG_arg_fail(2)) SWIG_fail;
15056 }
15057 {
15058 arg3 = (int)(SWIG_As_int(obj2));
15059 if (SWIG_arg_fail(3)) SWIG_fail;
15060 }
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 {
15069 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15070 }
15071 return resultobj;
15072 fail:
15073 return NULL;
15074 }
15075
15076
15077 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15078 PyObject *resultobj;
15079 wxGrid *arg1 = (wxGrid *) 0 ;
15080 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 char *kwnames[] = {
15084 (char *) "self",(char *) "editor", NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(1)) SWIG_fail;
15090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15091 if (SWIG_arg_fail(2)) SWIG_fail;
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 (arg1)->SetDefaultEditor(arg2);
15095
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 Py_INCREF(Py_None); resultobj = Py_None;
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15107 PyObject *resultobj;
15108 wxGrid *arg1 = (wxGrid *) 0 ;
15109 int arg2 ;
15110 int arg3 ;
15111 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15112 PyObject * obj0 = 0 ;
15113 PyObject * obj1 = 0 ;
15114 PyObject * obj2 = 0 ;
15115 PyObject * obj3 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 arg2 = (int)(SWIG_As_int(obj1));
15125 if (SWIG_arg_fail(2)) SWIG_fail;
15126 }
15127 {
15128 arg3 = (int)(SWIG_As_int(obj2));
15129 if (SWIG_arg_fail(3)) SWIG_fail;
15130 }
15131 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(4)) SWIG_fail;
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 (arg1)->SetCellEditor(arg2,arg3,arg4);
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 Py_INCREF(Py_None); resultobj = Py_None;
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj;
15149 wxGrid *arg1 = (wxGrid *) 0 ;
15150 wxGridCellEditor *result;
15151 PyObject * obj0 = 0 ;
15152 char *kwnames[] = {
15153 (char *) "self", NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(1)) SWIG_fail;
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15162
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 {
15167 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15168 }
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxGrid *arg1 = (wxGrid *) 0 ;
15178 int arg2 ;
15179 int arg3 ;
15180 wxGridCellEditor *result;
15181 PyObject * obj0 = 0 ;
15182 PyObject * obj1 = 0 ;
15183 PyObject * obj2 = 0 ;
15184 char *kwnames[] = {
15185 (char *) "self",(char *) "row",(char *) "col", NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15190 if (SWIG_arg_fail(1)) SWIG_fail;
15191 {
15192 arg2 = (int)(SWIG_As_int(obj1));
15193 if (SWIG_arg_fail(2)) SWIG_fail;
15194 }
15195 {
15196 arg3 = (int)(SWIG_As_int(obj2));
15197 if (SWIG_arg_fail(3)) SWIG_fail;
15198 }
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15202
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 {
15207 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15208 }
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15216 PyObject *resultobj;
15217 wxGrid *arg1 = (wxGrid *) 0 ;
15218 int arg2 ;
15219 int arg3 ;
15220 wxString result;
15221 PyObject * obj0 = 0 ;
15222 PyObject * obj1 = 0 ;
15223 PyObject * obj2 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self",(char *) "row",(char *) "col", NULL
15226 };
15227
15228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15230 if (SWIG_arg_fail(1)) SWIG_fail;
15231 {
15232 arg2 = (int)(SWIG_As_int(obj1));
15233 if (SWIG_arg_fail(2)) SWIG_fail;
15234 }
15235 {
15236 arg3 = (int)(SWIG_As_int(obj2));
15237 if (SWIG_arg_fail(3)) SWIG_fail;
15238 }
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (arg1)->GetCellValue(arg2,arg3);
15242
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 {
15247 #if wxUSE_UNICODE
15248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15249 #else
15250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15251 #endif
15252 }
15253 return resultobj;
15254 fail:
15255 return NULL;
15256 }
15257
15258
15259 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15260 PyObject *resultobj;
15261 wxGrid *arg1 = (wxGrid *) 0 ;
15262 int arg2 ;
15263 int arg3 ;
15264 wxString *arg4 = 0 ;
15265 bool temp4 = false ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 PyObject * obj2 = 0 ;
15269 PyObject * obj3 = 0 ;
15270 char *kwnames[] = {
15271 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15272 };
15273
15274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15276 if (SWIG_arg_fail(1)) SWIG_fail;
15277 {
15278 arg2 = (int)(SWIG_As_int(obj1));
15279 if (SWIG_arg_fail(2)) SWIG_fail;
15280 }
15281 {
15282 arg3 = (int)(SWIG_As_int(obj2));
15283 if (SWIG_arg_fail(3)) SWIG_fail;
15284 }
15285 {
15286 arg4 = wxString_in_helper(obj3);
15287 if (arg4 == NULL) SWIG_fail;
15288 temp4 = true;
15289 }
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15293
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 Py_INCREF(Py_None); resultobj = Py_None;
15298 {
15299 if (temp4)
15300 delete arg4;
15301 }
15302 return resultobj;
15303 fail:
15304 {
15305 if (temp4)
15306 delete arg4;
15307 }
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj;
15314 wxGrid *arg1 = (wxGrid *) 0 ;
15315 int arg2 ;
15316 int arg3 ;
15317 bool result;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 PyObject * obj2 = 0 ;
15321 char *kwnames[] = {
15322 (char *) "self",(char *) "row",(char *) "col", NULL
15323 };
15324
15325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15327 if (SWIG_arg_fail(1)) SWIG_fail;
15328 {
15329 arg2 = (int)(SWIG_As_int(obj1));
15330 if (SWIG_arg_fail(2)) SWIG_fail;
15331 }
15332 {
15333 arg3 = (int)(SWIG_As_int(obj2));
15334 if (SWIG_arg_fail(3)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 {
15344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15345 }
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15353 PyObject *resultobj;
15354 wxGrid *arg1 = (wxGrid *) 0 ;
15355 int arg2 ;
15356 int arg3 ;
15357 bool arg4 = (bool) true ;
15358 PyObject * obj0 = 0 ;
15359 PyObject * obj1 = 0 ;
15360 PyObject * obj2 = 0 ;
15361 PyObject * obj3 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 arg2 = (int)(SWIG_As_int(obj1));
15371 if (SWIG_arg_fail(2)) SWIG_fail;
15372 }
15373 {
15374 arg3 = (int)(SWIG_As_int(obj2));
15375 if (SWIG_arg_fail(3)) SWIG_fail;
15376 }
15377 if (obj3) {
15378 {
15379 arg4 = (bool)(SWIG_As_bool(obj3));
15380 if (SWIG_arg_fail(4)) SWIG_fail;
15381 }
15382 }
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 (arg1)->SetReadOnly(arg2,arg3,arg4);
15386
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 Py_INCREF(Py_None); resultobj = Py_None;
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15398 PyObject *resultobj;
15399 wxGrid *arg1 = (wxGrid *) 0 ;
15400 int arg2 ;
15401 bool arg3 = (bool) false ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 PyObject * obj2 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 {
15413 arg2 = (int)(SWIG_As_int(obj1));
15414 if (SWIG_arg_fail(2)) SWIG_fail;
15415 }
15416 if (obj2) {
15417 {
15418 arg3 = (bool)(SWIG_As_bool(obj2));
15419 if (SWIG_arg_fail(3)) SWIG_fail;
15420 }
15421 }
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 (arg1)->SelectRow(arg2,arg3);
15425
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 Py_INCREF(Py_None); resultobj = Py_None;
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15437 PyObject *resultobj;
15438 wxGrid *arg1 = (wxGrid *) 0 ;
15439 int arg2 ;
15440 bool arg3 = (bool) false ;
15441 PyObject * obj0 = 0 ;
15442 PyObject * obj1 = 0 ;
15443 PyObject * obj2 = 0 ;
15444 char *kwnames[] = {
15445 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15446 };
15447
15448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15450 if (SWIG_arg_fail(1)) SWIG_fail;
15451 {
15452 arg2 = (int)(SWIG_As_int(obj1));
15453 if (SWIG_arg_fail(2)) SWIG_fail;
15454 }
15455 if (obj2) {
15456 {
15457 arg3 = (bool)(SWIG_As_bool(obj2));
15458 if (SWIG_arg_fail(3)) SWIG_fail;
15459 }
15460 }
15461 {
15462 PyThreadState* __tstate = wxPyBeginAllowThreads();
15463 (arg1)->SelectCol(arg2,arg3);
15464
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 Py_INCREF(Py_None); resultobj = Py_None;
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15476 PyObject *resultobj;
15477 wxGrid *arg1 = (wxGrid *) 0 ;
15478 int arg2 ;
15479 int arg3 ;
15480 int arg4 ;
15481 int arg5 ;
15482 bool arg6 = (bool) false ;
15483 PyObject * obj0 = 0 ;
15484 PyObject * obj1 = 0 ;
15485 PyObject * obj2 = 0 ;
15486 PyObject * obj3 = 0 ;
15487 PyObject * obj4 = 0 ;
15488 PyObject * obj5 = 0 ;
15489 char *kwnames[] = {
15490 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15491 };
15492
15493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15495 if (SWIG_arg_fail(1)) SWIG_fail;
15496 {
15497 arg2 = (int)(SWIG_As_int(obj1));
15498 if (SWIG_arg_fail(2)) SWIG_fail;
15499 }
15500 {
15501 arg3 = (int)(SWIG_As_int(obj2));
15502 if (SWIG_arg_fail(3)) SWIG_fail;
15503 }
15504 {
15505 arg4 = (int)(SWIG_As_int(obj3));
15506 if (SWIG_arg_fail(4)) SWIG_fail;
15507 }
15508 {
15509 arg5 = (int)(SWIG_As_int(obj4));
15510 if (SWIG_arg_fail(5)) SWIG_fail;
15511 }
15512 if (obj5) {
15513 {
15514 arg6 = (bool)(SWIG_As_bool(obj5));
15515 if (SWIG_arg_fail(6)) SWIG_fail;
15516 }
15517 }
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15521
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 Py_INCREF(Py_None); resultobj = Py_None;
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj;
15534 wxGrid *arg1 = (wxGrid *) 0 ;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "self", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15542 if (SWIG_arg_fail(1)) SWIG_fail;
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 (arg1)->SelectAll();
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 Py_INCREF(Py_None); resultobj = Py_None;
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj;
15559 wxGrid *arg1 = (wxGrid *) 0 ;
15560 bool result;
15561 PyObject * obj0 = 0 ;
15562 char *kwnames[] = {
15563 (char *) "self", NULL
15564 };
15565
15566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15568 if (SWIG_arg_fail(1)) SWIG_fail;
15569 {
15570 PyThreadState* __tstate = wxPyBeginAllowThreads();
15571 result = (bool)(arg1)->IsSelection();
15572
15573 wxPyEndAllowThreads(__tstate);
15574 if (PyErr_Occurred()) SWIG_fail;
15575 }
15576 {
15577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15578 }
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15586 PyObject *resultobj;
15587 wxGrid *arg1 = (wxGrid *) 0 ;
15588 PyObject * obj0 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15595 if (SWIG_arg_fail(1)) SWIG_fail;
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 (arg1)->ClearSelection();
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 Py_INCREF(Py_None); resultobj = Py_None;
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj;
15612 wxGrid *arg1 = (wxGrid *) 0 ;
15613 int arg2 ;
15614 int arg3 ;
15615 bool result;
15616 PyObject * obj0 = 0 ;
15617 PyObject * obj1 = 0 ;
15618 PyObject * obj2 = 0 ;
15619 char *kwnames[] = {
15620 (char *) "self",(char *) "row",(char *) "col", NULL
15621 };
15622
15623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15625 if (SWIG_arg_fail(1)) SWIG_fail;
15626 {
15627 arg2 = (int)(SWIG_As_int(obj1));
15628 if (SWIG_arg_fail(2)) SWIG_fail;
15629 }
15630 {
15631 arg3 = (int)(SWIG_As_int(obj2));
15632 if (SWIG_arg_fail(3)) SWIG_fail;
15633 }
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15637
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj;
15652 wxGrid *arg1 = (wxGrid *) 0 ;
15653 wxGridCellCoordsArray result;
15654 PyObject * obj0 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = ((wxGrid const *)arg1)->GetSelectedCells();
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = wxGridCellCoordsArray_helper(result);
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj;
15680 wxGrid *arg1 = (wxGrid *) 0 ;
15681 wxGridCellCoordsArray result;
15682 PyObject * obj0 = 0 ;
15683 char *kwnames[] = {
15684 (char *) "self", NULL
15685 };
15686
15687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) goto fail;
15688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15689 if (SWIG_arg_fail(1)) SWIG_fail;
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15693
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 {
15698 resultobj = wxGridCellCoordsArray_helper(result);
15699 }
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15707 PyObject *resultobj;
15708 wxGrid *arg1 = (wxGrid *) 0 ;
15709 wxGridCellCoordsArray result;
15710 PyObject * obj0 = 0 ;
15711 char *kwnames[] = {
15712 (char *) "self", NULL
15713 };
15714
15715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15717 if (SWIG_arg_fail(1)) SWIG_fail;
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15721
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 {
15726 resultobj = wxGridCellCoordsArray_helper(result);
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxGrid *arg1 = (wxGrid *) 0 ;
15737 wxArrayInt result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = ((wxGrid const *)arg1)->GetSelectedRows();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = PyList_New(0);
15755 size_t idx;
15756 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15757 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15758 PyList_Append(resultobj, val);
15759 Py_DECREF(val);
15760 }
15761 }
15762 return resultobj;
15763 fail:
15764 return NULL;
15765 }
15766
15767
15768 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15769 PyObject *resultobj;
15770 wxGrid *arg1 = (wxGrid *) 0 ;
15771 wxArrayInt result;
15772 PyObject * obj0 = 0 ;
15773 char *kwnames[] = {
15774 (char *) "self", NULL
15775 };
15776
15777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15779 if (SWIG_arg_fail(1)) SWIG_fail;
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = ((wxGrid const *)arg1)->GetSelectedCols();
15783
15784 wxPyEndAllowThreads(__tstate);
15785 if (PyErr_Occurred()) SWIG_fail;
15786 }
15787 {
15788 resultobj = PyList_New(0);
15789 size_t idx;
15790 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15791 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15792 PyList_Append(resultobj, val);
15793 Py_DECREF(val);
15794 }
15795 }
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15803 PyObject *resultobj;
15804 wxGrid *arg1 = (wxGrid *) 0 ;
15805 int arg2 ;
15806 PyObject * obj0 = 0 ;
15807 PyObject * obj1 = 0 ;
15808 char *kwnames[] = {
15809 (char *) "self",(char *) "row", NULL
15810 };
15811
15812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
15813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15814 if (SWIG_arg_fail(1)) SWIG_fail;
15815 {
15816 arg2 = (int)(SWIG_As_int(obj1));
15817 if (SWIG_arg_fail(2)) SWIG_fail;
15818 }
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 (arg1)->DeselectRow(arg2);
15822
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 Py_INCREF(Py_None); resultobj = Py_None;
15827 return resultobj;
15828 fail:
15829 return NULL;
15830 }
15831
15832
15833 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj;
15835 wxGrid *arg1 = (wxGrid *) 0 ;
15836 int arg2 ;
15837 PyObject * obj0 = 0 ;
15838 PyObject * obj1 = 0 ;
15839 char *kwnames[] = {
15840 (char *) "self",(char *) "col", NULL
15841 };
15842
15843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
15844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15845 if (SWIG_arg_fail(1)) SWIG_fail;
15846 {
15847 arg2 = (int)(SWIG_As_int(obj1));
15848 if (SWIG_arg_fail(2)) SWIG_fail;
15849 }
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 (arg1)->DeselectCol(arg2);
15853
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 Py_INCREF(Py_None); resultobj = Py_None;
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj;
15866 wxGrid *arg1 = (wxGrid *) 0 ;
15867 int arg2 ;
15868 int arg3 ;
15869 PyObject * obj0 = 0 ;
15870 PyObject * obj1 = 0 ;
15871 PyObject * obj2 = 0 ;
15872 char *kwnames[] = {
15873 (char *) "self",(char *) "row",(char *) "col", NULL
15874 };
15875
15876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
15877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15878 if (SWIG_arg_fail(1)) SWIG_fail;
15879 {
15880 arg2 = (int)(SWIG_As_int(obj1));
15881 if (SWIG_arg_fail(2)) SWIG_fail;
15882 }
15883 {
15884 arg3 = (int)(SWIG_As_int(obj2));
15885 if (SWIG_arg_fail(3)) SWIG_fail;
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 (arg1)->DeselectCell(arg2,arg3);
15890
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 Py_INCREF(Py_None); resultobj = Py_None;
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
15902 PyObject *resultobj;
15903 wxGrid *arg1 = (wxGrid *) 0 ;
15904 wxGridCellCoords *arg2 = 0 ;
15905 wxGridCellCoords *arg3 = 0 ;
15906 wxRect result;
15907 wxGridCellCoords temp2 ;
15908 wxGridCellCoords temp3 ;
15909 PyObject * obj0 = 0 ;
15910 PyObject * obj1 = 0 ;
15911 PyObject * obj2 = 0 ;
15912 char *kwnames[] = {
15913 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
15914 };
15915
15916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
15917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15918 if (SWIG_arg_fail(1)) SWIG_fail;
15919 {
15920 arg2 = &temp2;
15921 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
15922 }
15923 {
15924 arg3 = &temp3;
15925 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
15926 }
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 wxRect * resultptr;
15936 resultptr = new wxRect((wxRect &)(result));
15937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15938 }
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxGrid *arg1 = (wxGrid *) 0 ;
15948 wxColour result;
15949 PyObject * obj0 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "self", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
15955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = ((wxGrid const *)arg1)->GetSelectionBackground();
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 {
15965 wxColour * resultptr;
15966 resultptr = new wxColour((wxColour &)(result));
15967 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15968 }
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxGrid *arg1 = (wxGrid *) 0 ;
15978 wxColour result;
15979 PyObject * obj0 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 result = ((wxGrid const *)arg1)->GetSelectionForeground();
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 {
15995 wxColour * resultptr;
15996 resultptr = new wxColour((wxColour &)(result));
15997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15998 }
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj;
16007 wxGrid *arg1 = (wxGrid *) 0 ;
16008 wxColour *arg2 = 0 ;
16009 wxColour temp2 ;
16010 PyObject * obj0 = 0 ;
16011 PyObject * obj1 = 0 ;
16012 char *kwnames[] = {
16013 (char *) "self",(char *) "c", NULL
16014 };
16015
16016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
16017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16018 if (SWIG_arg_fail(1)) SWIG_fail;
16019 {
16020 arg2 = &temp2;
16021 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16022 }
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 Py_INCREF(Py_None); resultobj = Py_None;
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj;
16039 wxGrid *arg1 = (wxGrid *) 0 ;
16040 wxColour *arg2 = 0 ;
16041 wxColour temp2 ;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 char *kwnames[] = {
16045 (char *) "self",(char *) "c", NULL
16046 };
16047
16048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) goto fail;
16049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16050 if (SWIG_arg_fail(1)) SWIG_fail;
16051 {
16052 arg2 = &temp2;
16053 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16054 }
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16058
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 Py_INCREF(Py_None); resultobj = Py_None;
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj;
16071 wxGrid *arg1 = (wxGrid *) 0 ;
16072 wxString *arg2 = 0 ;
16073 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16074 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16075 bool temp2 = false ;
16076 PyObject * obj0 = 0 ;
16077 PyObject * obj1 = 0 ;
16078 PyObject * obj2 = 0 ;
16079 PyObject * obj3 = 0 ;
16080 char *kwnames[] = {
16081 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16082 };
16083
16084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16086 if (SWIG_arg_fail(1)) SWIG_fail;
16087 {
16088 arg2 = wxString_in_helper(obj1);
16089 if (arg2 == NULL) SWIG_fail;
16090 temp2 = true;
16091 }
16092 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16093 if (SWIG_arg_fail(3)) SWIG_fail;
16094 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16095 if (SWIG_arg_fail(4)) SWIG_fail;
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16099
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 Py_INCREF(Py_None); resultobj = Py_None;
16104 {
16105 if (temp2)
16106 delete arg2;
16107 }
16108 return resultobj;
16109 fail:
16110 {
16111 if (temp2)
16112 delete arg2;
16113 }
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxGrid *arg1 = (wxGrid *) 0 ;
16121 int arg2 ;
16122 int arg3 ;
16123 wxGridCellEditor *result;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self",(char *) "row",(char *) "col", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 arg2 = (int)(SWIG_As_int(obj1));
16136 if (SWIG_arg_fail(2)) SWIG_fail;
16137 }
16138 {
16139 arg3 = (int)(SWIG_As_int(obj2));
16140 if (SWIG_arg_fail(3)) SWIG_fail;
16141 }
16142 {
16143 PyThreadState* __tstate = wxPyBeginAllowThreads();
16144 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16145
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 {
16150 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16151 }
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj;
16160 wxGrid *arg1 = (wxGrid *) 0 ;
16161 int arg2 ;
16162 int arg3 ;
16163 wxGridCellRenderer *result;
16164 PyObject * obj0 = 0 ;
16165 PyObject * obj1 = 0 ;
16166 PyObject * obj2 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self",(char *) "row",(char *) "col", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 arg2 = (int)(SWIG_As_int(obj1));
16176 if (SWIG_arg_fail(2)) SWIG_fail;
16177 }
16178 {
16179 arg3 = (int)(SWIG_As_int(obj2));
16180 if (SWIG_arg_fail(3)) SWIG_fail;
16181 }
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16185
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 {
16190 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16191 }
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16199 PyObject *resultobj;
16200 wxGrid *arg1 = (wxGrid *) 0 ;
16201 wxString *arg2 = 0 ;
16202 wxGridCellEditor *result;
16203 bool temp2 = false ;
16204 PyObject * obj0 = 0 ;
16205 PyObject * obj1 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "self",(char *) "typeName", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 arg2 = wxString_in_helper(obj1);
16215 if (arg2 == NULL) SWIG_fail;
16216 temp2 = true;
16217 }
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16221
16222 wxPyEndAllowThreads(__tstate);
16223 if (PyErr_Occurred()) SWIG_fail;
16224 }
16225 {
16226 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16227 }
16228 {
16229 if (temp2)
16230 delete arg2;
16231 }
16232 return resultobj;
16233 fail:
16234 {
16235 if (temp2)
16236 delete arg2;
16237 }
16238 return NULL;
16239 }
16240
16241
16242 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj;
16244 wxGrid *arg1 = (wxGrid *) 0 ;
16245 wxString *arg2 = 0 ;
16246 wxGridCellRenderer *result;
16247 bool temp2 = false ;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 char *kwnames[] = {
16251 (char *) "self",(char *) "typeName", NULL
16252 };
16253
16254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16256 if (SWIG_arg_fail(1)) SWIG_fail;
16257 {
16258 arg2 = wxString_in_helper(obj1);
16259 if (arg2 == NULL) SWIG_fail;
16260 temp2 = true;
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16265
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 {
16270 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16271 }
16272 {
16273 if (temp2)
16274 delete arg2;
16275 }
16276 return resultobj;
16277 fail:
16278 {
16279 if (temp2)
16280 delete arg2;
16281 }
16282 return NULL;
16283 }
16284
16285
16286 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj;
16288 wxGrid *arg1 = (wxGrid *) 0 ;
16289 int arg2 ;
16290 int arg3 ;
16291 PyObject * obj0 = 0 ;
16292 PyObject * obj1 = 0 ;
16293 PyObject * obj2 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 arg2 = (int)(SWIG_As_int(obj1));
16303 if (SWIG_arg_fail(2)) SWIG_fail;
16304 }
16305 {
16306 arg3 = (int)(SWIG_As_int(obj2));
16307 if (SWIG_arg_fail(3)) SWIG_fail;
16308 }
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 (arg1)->SetMargins(arg2,arg3);
16312
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 Py_INCREF(Py_None); resultobj = Py_None;
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj;
16325 wxGrid *arg1 = (wxGrid *) 0 ;
16326 wxWindow *result;
16327 PyObject * obj0 = 0 ;
16328 char *kwnames[] = {
16329 (char *) "self", NULL
16330 };
16331
16332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16334 if (SWIG_arg_fail(1)) SWIG_fail;
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (wxWindow *)(arg1)->GetGridWindow();
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = wxPyMake_wxObject(result, 0);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxGrid *arg1 = (wxGrid *) 0 ;
16354 wxWindow *result;
16355 PyObject * obj0 = 0 ;
16356 char *kwnames[] = {
16357 (char *) "self", NULL
16358 };
16359
16360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16362 if (SWIG_arg_fail(1)) SWIG_fail;
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16366
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 resultobj = wxPyMake_wxObject(result, 0);
16372 }
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxGrid *arg1 = (wxGrid *) 0 ;
16382 wxWindow *result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 resultobj = wxPyMake_wxObject(result, 0);
16400 }
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxGrid *arg1 = (wxGrid *) 0 ;
16410 wxWindow *result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 resultobj = wxPyMake_wxObject(result, 0);
16428 }
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj;
16437 wxGrid *arg1 = (wxGrid *) 0 ;
16438 int arg2 ;
16439 PyObject * obj0 = 0 ;
16440 PyObject * obj1 = 0 ;
16441 char *kwnames[] = {
16442 (char *) "self",(char *) "x", NULL
16443 };
16444
16445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16447 if (SWIG_arg_fail(1)) SWIG_fail;
16448 {
16449 arg2 = (int)(SWIG_As_int(obj1));
16450 if (SWIG_arg_fail(2)) SWIG_fail;
16451 }
16452 {
16453 PyThreadState* __tstate = wxPyBeginAllowThreads();
16454 (arg1)->SetScrollLineX(arg2);
16455
16456 wxPyEndAllowThreads(__tstate);
16457 if (PyErr_Occurred()) SWIG_fail;
16458 }
16459 Py_INCREF(Py_None); resultobj = Py_None;
16460 return resultobj;
16461 fail:
16462 return NULL;
16463 }
16464
16465
16466 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj;
16468 wxGrid *arg1 = (wxGrid *) 0 ;
16469 int arg2 ;
16470 PyObject * obj0 = 0 ;
16471 PyObject * obj1 = 0 ;
16472 char *kwnames[] = {
16473 (char *) "self",(char *) "y", NULL
16474 };
16475
16476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16478 if (SWIG_arg_fail(1)) SWIG_fail;
16479 {
16480 arg2 = (int)(SWIG_As_int(obj1));
16481 if (SWIG_arg_fail(2)) SWIG_fail;
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 (arg1)->SetScrollLineY(arg2);
16486
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 Py_INCREF(Py_None); resultobj = Py_None;
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj;
16499 wxGrid *arg1 = (wxGrid *) 0 ;
16500 int result;
16501 PyObject * obj0 = 0 ;
16502 char *kwnames[] = {
16503 (char *) "self", NULL
16504 };
16505
16506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16508 if (SWIG_arg_fail(1)) SWIG_fail;
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16512
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = SWIG_From_int((int)(result));
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj;
16527 wxGrid *arg1 = (wxGrid *) 0 ;
16528 int result;
16529 PyObject * obj0 = 0 ;
16530 char *kwnames[] = {
16531 (char *) "self", NULL
16532 };
16533
16534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16536 if (SWIG_arg_fail(1)) SWIG_fail;
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16540
16541 wxPyEndAllowThreads(__tstate);
16542 if (PyErr_Occurred()) SWIG_fail;
16543 }
16544 {
16545 resultobj = SWIG_From_int((int)(result));
16546 }
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 wxGrid *arg1 = (wxGrid *) 0 ;
16556 int arg2 ;
16557 int result;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self",(char *) "x", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 arg2 = (int)(SWIG_As_int(obj1));
16569 if (SWIG_arg_fail(2)) SWIG_fail;
16570 }
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 resultobj = SWIG_From_int((int)(result));
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxGrid *arg1 = (wxGrid *) 0 ;
16590 int arg2 ;
16591 int result;
16592 PyObject * obj0 = 0 ;
16593 PyObject * obj1 = 0 ;
16594 char *kwnames[] = {
16595 (char *) "self",(char *) "y", NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) goto fail;
16599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16600 if (SWIG_arg_fail(1)) SWIG_fail;
16601 {
16602 arg2 = (int)(SWIG_As_int(obj1));
16603 if (SWIG_arg_fail(2)) SWIG_fail;
16604 }
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16608
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 {
16613 resultobj = SWIG_From_int((int)(result));
16614 }
16615 return resultobj;
16616 fail:
16617 return NULL;
16618 }
16619
16620
16621 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj;
16623 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16624 wxVisualAttributes result;
16625 PyObject * obj0 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "variant", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16631 if (obj0) {
16632 {
16633 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16634 if (SWIG_arg_fail(1)) SWIG_fail;
16635 }
16636 }
16637 {
16638 if (!wxPyCheckForApp()) SWIG_fail;
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 result = wxGrid::GetClassDefaultAttributes((wxWindowVariant )arg1);
16641
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 {
16646 wxVisualAttributes * resultptr;
16647 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16649 }
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16657 PyObject *obj;
16658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16659 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16660 Py_INCREF(obj);
16661 return Py_BuildValue((char *)"");
16662 }
16663 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16664 PyObject *resultobj;
16665 int arg1 ;
16666 wxEventType arg2 ;
16667 wxGrid *arg3 = (wxGrid *) 0 ;
16668 int arg4 = (int) -1 ;
16669 int arg5 = (int) -1 ;
16670 int arg6 = (int) -1 ;
16671 int arg7 = (int) -1 ;
16672 bool arg8 = (bool) true ;
16673 bool arg9 = (bool) false ;
16674 bool arg10 = (bool) false ;
16675 bool arg11 = (bool) false ;
16676 bool arg12 = (bool) false ;
16677 wxGridEvent *result;
16678 PyObject * obj0 = 0 ;
16679 PyObject * obj1 = 0 ;
16680 PyObject * obj2 = 0 ;
16681 PyObject * obj3 = 0 ;
16682 PyObject * obj4 = 0 ;
16683 PyObject * obj5 = 0 ;
16684 PyObject * obj6 = 0 ;
16685 PyObject * obj7 = 0 ;
16686 PyObject * obj8 = 0 ;
16687 PyObject * obj9 = 0 ;
16688 PyObject * obj10 = 0 ;
16689 PyObject * obj11 = 0 ;
16690 char *kwnames[] = {
16691 (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
16692 };
16693
16694 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;
16695 {
16696 arg1 = (int)(SWIG_As_int(obj0));
16697 if (SWIG_arg_fail(1)) SWIG_fail;
16698 }
16699 {
16700 arg2 = (wxEventType)(SWIG_As_int(obj1));
16701 if (SWIG_arg_fail(2)) SWIG_fail;
16702 }
16703 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(3)) SWIG_fail;
16705 if (obj3) {
16706 {
16707 arg4 = (int)(SWIG_As_int(obj3));
16708 if (SWIG_arg_fail(4)) SWIG_fail;
16709 }
16710 }
16711 if (obj4) {
16712 {
16713 arg5 = (int)(SWIG_As_int(obj4));
16714 if (SWIG_arg_fail(5)) SWIG_fail;
16715 }
16716 }
16717 if (obj5) {
16718 {
16719 arg6 = (int)(SWIG_As_int(obj5));
16720 if (SWIG_arg_fail(6)) SWIG_fail;
16721 }
16722 }
16723 if (obj6) {
16724 {
16725 arg7 = (int)(SWIG_As_int(obj6));
16726 if (SWIG_arg_fail(7)) SWIG_fail;
16727 }
16728 }
16729 if (obj7) {
16730 {
16731 arg8 = (bool)(SWIG_As_bool(obj7));
16732 if (SWIG_arg_fail(8)) SWIG_fail;
16733 }
16734 }
16735 if (obj8) {
16736 {
16737 arg9 = (bool)(SWIG_As_bool(obj8));
16738 if (SWIG_arg_fail(9)) SWIG_fail;
16739 }
16740 }
16741 if (obj9) {
16742 {
16743 arg10 = (bool)(SWIG_As_bool(obj9));
16744 if (SWIG_arg_fail(10)) SWIG_fail;
16745 }
16746 }
16747 if (obj10) {
16748 {
16749 arg11 = (bool)(SWIG_As_bool(obj10));
16750 if (SWIG_arg_fail(11)) SWIG_fail;
16751 }
16752 }
16753 if (obj11) {
16754 {
16755 arg12 = (bool)(SWIG_As_bool(obj11));
16756 if (SWIG_arg_fail(12)) SWIG_fail;
16757 }
16758 }
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16762
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16776 int result;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 result = (int)(arg1)->GetRow();
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 resultobj = SWIG_From_int((int)(result));
16794 }
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj;
16803 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16804 int result;
16805 PyObject * obj0 = 0 ;
16806 char *kwnames[] = {
16807 (char *) "self", NULL
16808 };
16809
16810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
16811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16812 if (SWIG_arg_fail(1)) SWIG_fail;
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = (int)(arg1)->GetCol();
16816
16817 wxPyEndAllowThreads(__tstate);
16818 if (PyErr_Occurred()) SWIG_fail;
16819 }
16820 {
16821 resultobj = SWIG_From_int((int)(result));
16822 }
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16832 wxPoint result;
16833 PyObject * obj0 = 0 ;
16834 char *kwnames[] = {
16835 (char *) "self", NULL
16836 };
16837
16838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
16839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16840 if (SWIG_arg_fail(1)) SWIG_fail;
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = (arg1)->GetPosition();
16844
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 {
16849 wxPoint * resultptr;
16850 resultptr = new wxPoint((wxPoint &)(result));
16851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16852 }
16853 return resultobj;
16854 fail:
16855 return NULL;
16856 }
16857
16858
16859 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
16860 PyObject *resultobj;
16861 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16862 bool result;
16863 PyObject * obj0 = 0 ;
16864 char *kwnames[] = {
16865 (char *) "self", NULL
16866 };
16867
16868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
16869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16870 if (SWIG_arg_fail(1)) SWIG_fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (bool)(arg1)->Selecting();
16874
16875 wxPyEndAllowThreads(__tstate);
16876 if (PyErr_Occurred()) SWIG_fail;
16877 }
16878 {
16879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16880 }
16881 return resultobj;
16882 fail:
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16890 bool result;
16891 PyObject * obj0 = 0 ;
16892 char *kwnames[] = {
16893 (char *) "self", NULL
16894 };
16895
16896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
16897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16898 if (SWIG_arg_fail(1)) SWIG_fail;
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)(arg1)->ControlDown();
16902
16903 wxPyEndAllowThreads(__tstate);
16904 if (PyErr_Occurred()) SWIG_fail;
16905 }
16906 {
16907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16908 }
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj;
16917 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16918 bool result;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 result = (bool)(arg1)->MetaDown();
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 {
16935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16936 }
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj;
16945 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16946 bool result;
16947 PyObject * obj0 = 0 ;
16948 char *kwnames[] = {
16949 (char *) "self", NULL
16950 };
16951
16952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
16953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16954 if (SWIG_arg_fail(1)) SWIG_fail;
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = (bool)(arg1)->ShiftDown();
16958
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 {
16963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16964 }
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj;
16973 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16974 bool result;
16975 PyObject * obj0 = 0 ;
16976 char *kwnames[] = {
16977 (char *) "self", NULL
16978 };
16979
16980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
16981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16982 if (SWIG_arg_fail(1)) SWIG_fail;
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (bool)(arg1)->AltDown();
16986
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 {
16991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16992 }
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
17000 PyObject *obj;
17001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17002 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
17003 Py_INCREF(obj);
17004 return Py_BuildValue((char *)"");
17005 }
17006 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj;
17008 int arg1 ;
17009 wxEventType arg2 ;
17010 wxGrid *arg3 = (wxGrid *) 0 ;
17011 int arg4 = (int) -1 ;
17012 int arg5 = (int) -1 ;
17013 int arg6 = (int) -1 ;
17014 bool arg7 = (bool) false ;
17015 bool arg8 = (bool) false ;
17016 bool arg9 = (bool) false ;
17017 bool arg10 = (bool) false ;
17018 wxGridSizeEvent *result;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 PyObject * obj2 = 0 ;
17022 PyObject * obj3 = 0 ;
17023 PyObject * obj4 = 0 ;
17024 PyObject * obj5 = 0 ;
17025 PyObject * obj6 = 0 ;
17026 PyObject * obj7 = 0 ;
17027 PyObject * obj8 = 0 ;
17028 PyObject * obj9 = 0 ;
17029 char *kwnames[] = {
17030 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17031 };
17032
17033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17034 {
17035 arg1 = (int)(SWIG_As_int(obj0));
17036 if (SWIG_arg_fail(1)) SWIG_fail;
17037 }
17038 {
17039 arg2 = (wxEventType)(SWIG_As_int(obj1));
17040 if (SWIG_arg_fail(2)) SWIG_fail;
17041 }
17042 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17043 if (SWIG_arg_fail(3)) SWIG_fail;
17044 if (obj3) {
17045 {
17046 arg4 = (int)(SWIG_As_int(obj3));
17047 if (SWIG_arg_fail(4)) SWIG_fail;
17048 }
17049 }
17050 if (obj4) {
17051 {
17052 arg5 = (int)(SWIG_As_int(obj4));
17053 if (SWIG_arg_fail(5)) SWIG_fail;
17054 }
17055 }
17056 if (obj5) {
17057 {
17058 arg6 = (int)(SWIG_As_int(obj5));
17059 if (SWIG_arg_fail(6)) SWIG_fail;
17060 }
17061 }
17062 if (obj6) {
17063 {
17064 arg7 = (bool)(SWIG_As_bool(obj6));
17065 if (SWIG_arg_fail(7)) SWIG_fail;
17066 }
17067 }
17068 if (obj7) {
17069 {
17070 arg8 = (bool)(SWIG_As_bool(obj7));
17071 if (SWIG_arg_fail(8)) SWIG_fail;
17072 }
17073 }
17074 if (obj8) {
17075 {
17076 arg9 = (bool)(SWIG_As_bool(obj8));
17077 if (SWIG_arg_fail(9)) SWIG_fail;
17078 }
17079 }
17080 if (obj9) {
17081 {
17082 arg10 = (bool)(SWIG_As_bool(obj9));
17083 if (SWIG_arg_fail(10)) SWIG_fail;
17084 }
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17089
17090 wxPyEndAllowThreads(__tstate);
17091 if (PyErr_Occurred()) SWIG_fail;
17092 }
17093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj;
17102 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17103 int result;
17104 PyObject * obj0 = 0 ;
17105 char *kwnames[] = {
17106 (char *) "self", NULL
17107 };
17108
17109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17111 if (SWIG_arg_fail(1)) SWIG_fail;
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 result = (int)(arg1)->GetRowOrCol();
17115
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 {
17120 resultobj = SWIG_From_int((int)(result));
17121 }
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17131 wxPoint result;
17132 PyObject * obj0 = 0 ;
17133 char *kwnames[] = {
17134 (char *) "self", NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17139 if (SWIG_arg_fail(1)) SWIG_fail;
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (arg1)->GetPosition();
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 wxPoint * resultptr;
17149 resultptr = new wxPoint((wxPoint &)(result));
17150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17151 }
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17161 bool result;
17162 PyObject * obj0 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17169 if (SWIG_arg_fail(1)) SWIG_fail;
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (bool)(arg1)->ControlDown();
17173
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 {
17178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17179 }
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17189 bool result;
17190 PyObject * obj0 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "self", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 result = (bool)(arg1)->MetaDown();
17201
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17207 }
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj;
17216 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17217 bool result;
17218 PyObject * obj0 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17225 if (SWIG_arg_fail(1)) SWIG_fail;
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (bool)(arg1)->ShiftDown();
17229
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 {
17234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17235 }
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj;
17244 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17245 bool result;
17246 PyObject * obj0 = 0 ;
17247 char *kwnames[] = {
17248 (char *) "self", NULL
17249 };
17250
17251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17253 if (SWIG_arg_fail(1)) SWIG_fail;
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (bool)(arg1)->AltDown();
17257
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17271 PyObject *obj;
17272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17273 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17274 Py_INCREF(obj);
17275 return Py_BuildValue((char *)"");
17276 }
17277 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 int arg1 ;
17280 wxEventType arg2 ;
17281 wxGrid *arg3 = (wxGrid *) 0 ;
17282 wxGridCellCoords *arg4 = 0 ;
17283 wxGridCellCoords *arg5 = 0 ;
17284 bool arg6 = (bool) true ;
17285 bool arg7 = (bool) false ;
17286 bool arg8 = (bool) false ;
17287 bool arg9 = (bool) false ;
17288 bool arg10 = (bool) false ;
17289 wxGridRangeSelectEvent *result;
17290 wxGridCellCoords temp4 ;
17291 wxGridCellCoords temp5 ;
17292 PyObject * obj0 = 0 ;
17293 PyObject * obj1 = 0 ;
17294 PyObject * obj2 = 0 ;
17295 PyObject * obj3 = 0 ;
17296 PyObject * obj4 = 0 ;
17297 PyObject * obj5 = 0 ;
17298 PyObject * obj6 = 0 ;
17299 PyObject * obj7 = 0 ;
17300 PyObject * obj8 = 0 ;
17301 PyObject * obj9 = 0 ;
17302 char *kwnames[] = {
17303 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17304 };
17305
17306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17307 {
17308 arg1 = (int)(SWIG_As_int(obj0));
17309 if (SWIG_arg_fail(1)) SWIG_fail;
17310 }
17311 {
17312 arg2 = (wxEventType)(SWIG_As_int(obj1));
17313 if (SWIG_arg_fail(2)) SWIG_fail;
17314 }
17315 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(3)) SWIG_fail;
17317 {
17318 arg4 = &temp4;
17319 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17320 }
17321 {
17322 arg5 = &temp5;
17323 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17324 }
17325 if (obj5) {
17326 {
17327 arg6 = (bool)(SWIG_As_bool(obj5));
17328 if (SWIG_arg_fail(6)) SWIG_fail;
17329 }
17330 }
17331 if (obj6) {
17332 {
17333 arg7 = (bool)(SWIG_As_bool(obj6));
17334 if (SWIG_arg_fail(7)) SWIG_fail;
17335 }
17336 }
17337 if (obj7) {
17338 {
17339 arg8 = (bool)(SWIG_As_bool(obj7));
17340 if (SWIG_arg_fail(8)) SWIG_fail;
17341 }
17342 }
17343 if (obj8) {
17344 {
17345 arg9 = (bool)(SWIG_As_bool(obj8));
17346 if (SWIG_arg_fail(9)) SWIG_fail;
17347 }
17348 }
17349 if (obj9) {
17350 {
17351 arg10 = (bool)(SWIG_As_bool(obj9));
17352 if (SWIG_arg_fail(10)) SWIG_fail;
17353 }
17354 }
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj;
17371 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17372 wxGridCellCoords result;
17373 PyObject * obj0 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = (arg1)->GetTopLeftCoords();
17384
17385 wxPyEndAllowThreads(__tstate);
17386 if (PyErr_Occurred()) SWIG_fail;
17387 }
17388 {
17389 wxGridCellCoords * resultptr;
17390 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17391 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17392 }
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj;
17401 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17402 wxGridCellCoords result;
17403 PyObject * obj0 = 0 ;
17404 char *kwnames[] = {
17405 (char *) "self", NULL
17406 };
17407
17408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17410 if (SWIG_arg_fail(1)) SWIG_fail;
17411 {
17412 PyThreadState* __tstate = wxPyBeginAllowThreads();
17413 result = (arg1)->GetBottomRightCoords();
17414
17415 wxPyEndAllowThreads(__tstate);
17416 if (PyErr_Occurred()) SWIG_fail;
17417 }
17418 {
17419 wxGridCellCoords * resultptr;
17420 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)(arg1)->GetTopRow();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)(arg1)->GetBottomRow();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17488 int result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (int)(arg1)->GetLeftCol();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = SWIG_From_int((int)(result));
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17516 int result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (int)(arg1)->GetRightCol();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = SWIG_From_int((int)(result));
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17544 bool result;
17545 PyObject * obj0 = 0 ;
17546 char *kwnames[] = {
17547 (char *) "self", NULL
17548 };
17549
17550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17552 if (SWIG_arg_fail(1)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)(arg1)->Selecting();
17556
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17570 PyObject *resultobj;
17571 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17572 bool result;
17573 PyObject * obj0 = 0 ;
17574 char *kwnames[] = {
17575 (char *) "self", NULL
17576 };
17577
17578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17580 if (SWIG_arg_fail(1)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (bool)(arg1)->ControlDown();
17584
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17590 }
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj;
17599 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17600 bool result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (bool)(arg1)->MetaDown();
17612
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj;
17627 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17628 bool result;
17629 PyObject * obj0 = 0 ;
17630 char *kwnames[] = {
17631 (char *) "self", NULL
17632 };
17633
17634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17636 if (SWIG_arg_fail(1)) SWIG_fail;
17637 {
17638 PyThreadState* __tstate = wxPyBeginAllowThreads();
17639 result = (bool)(arg1)->ShiftDown();
17640
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17656 bool result;
17657 PyObject * obj0 = 0 ;
17658 char *kwnames[] = {
17659 (char *) "self", NULL
17660 };
17661
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)(arg1)->AltDown();
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17682 PyObject *obj;
17683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17684 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17685 Py_INCREF(obj);
17686 return Py_BuildValue((char *)"");
17687 }
17688 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 int arg1 ;
17691 wxEventType arg2 ;
17692 wxObject *arg3 = (wxObject *) 0 ;
17693 int arg4 ;
17694 int arg5 ;
17695 wxControl *arg6 = (wxControl *) 0 ;
17696 wxGridEditorCreatedEvent *result;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 PyObject * obj2 = 0 ;
17700 PyObject * obj3 = 0 ;
17701 PyObject * obj4 = 0 ;
17702 PyObject * obj5 = 0 ;
17703 char *kwnames[] = {
17704 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17705 };
17706
17707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17708 {
17709 arg1 = (int)(SWIG_As_int(obj0));
17710 if (SWIG_arg_fail(1)) SWIG_fail;
17711 }
17712 {
17713 arg2 = (wxEventType)(SWIG_As_int(obj1));
17714 if (SWIG_arg_fail(2)) SWIG_fail;
17715 }
17716 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17717 if (SWIG_arg_fail(3)) SWIG_fail;
17718 {
17719 arg4 = (int)(SWIG_As_int(obj3));
17720 if (SWIG_arg_fail(4)) SWIG_fail;
17721 }
17722 {
17723 arg5 = (int)(SWIG_As_int(obj4));
17724 if (SWIG_arg_fail(5)) SWIG_fail;
17725 }
17726 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17727 if (SWIG_arg_fail(6)) SWIG_fail;
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17731
17732 wxPyEndAllowThreads(__tstate);
17733 if (PyErr_Occurred()) SWIG_fail;
17734 }
17735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17736 return resultobj;
17737 fail:
17738 return NULL;
17739 }
17740
17741
17742 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17743 PyObject *resultobj;
17744 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17745 int result;
17746 PyObject * obj0 = 0 ;
17747 char *kwnames[] = {
17748 (char *) "self", NULL
17749 };
17750
17751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17753 if (SWIG_arg_fail(1)) SWIG_fail;
17754 {
17755 PyThreadState* __tstate = wxPyBeginAllowThreads();
17756 result = (int)(arg1)->GetRow();
17757
17758 wxPyEndAllowThreads(__tstate);
17759 if (PyErr_Occurred()) SWIG_fail;
17760 }
17761 {
17762 resultobj = SWIG_From_int((int)(result));
17763 }
17764 return resultobj;
17765 fail:
17766 return NULL;
17767 }
17768
17769
17770 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17771 PyObject *resultobj;
17772 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17773 int result;
17774 PyObject * obj0 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 result = (int)(arg1)->GetCol();
17785
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 {
17790 resultobj = SWIG_From_int((int)(result));
17791 }
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj;
17800 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17801 wxControl *result;
17802 PyObject * obj0 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = (wxControl *)(arg1)->GetControl();
17813
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 resultobj = wxPyMake_wxObject(result, 0);
17819 }
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17829 int arg2 ;
17830 PyObject * obj0 = 0 ;
17831 PyObject * obj1 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "self",(char *) "row", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
17837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17838 if (SWIG_arg_fail(1)) SWIG_fail;
17839 {
17840 arg2 = (int)(SWIG_As_int(obj1));
17841 if (SWIG_arg_fail(2)) SWIG_fail;
17842 }
17843 {
17844 PyThreadState* __tstate = wxPyBeginAllowThreads();
17845 (arg1)->SetRow(arg2);
17846
17847 wxPyEndAllowThreads(__tstate);
17848 if (PyErr_Occurred()) SWIG_fail;
17849 }
17850 Py_INCREF(Py_None); resultobj = Py_None;
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj;
17859 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17860 int arg2 ;
17861 PyObject * obj0 = 0 ;
17862 PyObject * obj1 = 0 ;
17863 char *kwnames[] = {
17864 (char *) "self",(char *) "col", NULL
17865 };
17866
17867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
17868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17869 if (SWIG_arg_fail(1)) SWIG_fail;
17870 {
17871 arg2 = (int)(SWIG_As_int(obj1));
17872 if (SWIG_arg_fail(2)) SWIG_fail;
17873 }
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 (arg1)->SetCol(arg2);
17877
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 Py_INCREF(Py_None); resultobj = Py_None;
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj;
17890 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17891 wxControl *arg2 = (wxControl *) 0 ;
17892 PyObject * obj0 = 0 ;
17893 PyObject * obj1 = 0 ;
17894 char *kwnames[] = {
17895 (char *) "self",(char *) "ctrl", NULL
17896 };
17897
17898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
17899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17900 if (SWIG_arg_fail(1)) SWIG_fail;
17901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17902 if (SWIG_arg_fail(2)) SWIG_fail;
17903 {
17904 PyThreadState* __tstate = wxPyBeginAllowThreads();
17905 (arg1)->SetControl(arg2);
17906
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 Py_INCREF(Py_None); resultobj = Py_None;
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
17918 PyObject *obj;
17919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17920 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
17921 Py_INCREF(obj);
17922 return Py_BuildValue((char *)"");
17923 }
17924 static PyMethodDef SwigMethods[] = {
17925 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17926 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17927 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17928 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17929 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
17930 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
17931 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17932 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
17933 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17934 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17935 { (char *)"PyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17936 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
17937 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17938 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
17939 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17940 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
17941 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17942 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17943 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17944 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17945 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17946 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
17947 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17948 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
17949 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17950 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
17951 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17952 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
17953 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17954 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
17955 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17956 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
17957 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17958 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17959 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17960 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17961 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17962 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17963 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17964 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
17965 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17966 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17967 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
17968 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17969 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17970 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17971 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17972 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17973 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17974 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17975 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17976 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17977 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
17978 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17979 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17980 { (char *)"PyGridCellEditor_base_SetSize", (PyCFunction) _wrap_PyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17981 { (char *)"PyGridCellEditor_base_Show", (PyCFunction) _wrap_PyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17982 { (char *)"PyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17983 { (char *)"PyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17984 { (char *)"PyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17985 { (char *)"PyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17986 { (char *)"PyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17987 { (char *)"PyGridCellEditor_base_Destroy", (PyCFunction) _wrap_PyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17988 { (char *)"PyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17989 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
17990 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17991 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17992 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
17993 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17994 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17995 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
17996 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17997 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17998 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
17999 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18000 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18001 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
18002 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18003 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18004 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
18005 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18006 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18007 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
18008 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18009 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18010 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
18011 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18012 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18013 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18014 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
18015 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18016 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18017 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18018 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18019 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18020 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18021 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18022 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18023 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18024 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18025 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18026 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18027 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18028 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18029 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18030 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18031 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18032 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18033 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18034 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18035 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18036 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18037 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18038 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18039 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18040 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18041 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18042 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18043 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18044 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18045 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18046 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18047 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18048 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18049 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18050 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18051 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18052 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18053 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18054 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18055 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18056 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18057 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18058 { (char *)"PyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18059 { (char *)"PyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18060 { (char *)"PyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18061 { (char *)"PyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18062 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18063 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18064 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18065 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18066 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18067 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18068 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18069 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18070 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18071 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18072 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18073 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18074 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18075 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18076 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18077 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18078 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18079 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18080 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18081 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18082 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18083 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18084 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18085 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18086 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18087 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18088 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18089 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18090 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18091 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18092 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18093 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18094 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18095 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18096 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18097 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18098 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18099 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18100 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18101 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18102 { (char *)"PyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18103 { (char *)"PyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18104 { (char *)"PyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18105 { (char *)"PyGridTableBase_base_Clear", (PyCFunction) _wrap_PyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18106 { (char *)"PyGridTableBase_base_InsertRows", (PyCFunction) _wrap_PyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18107 { (char *)"PyGridTableBase_base_AppendRows", (PyCFunction) _wrap_PyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18108 { (char *)"PyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18109 { (char *)"PyGridTableBase_base_InsertCols", (PyCFunction) _wrap_PyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18110 { (char *)"PyGridTableBase_base_AppendCols", (PyCFunction) _wrap_PyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18111 { (char *)"PyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18112 { (char *)"PyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18113 { (char *)"PyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18114 { (char *)"PyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18115 { (char *)"PyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18116 { (char *)"PyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18117 { (char *)"PyGridTableBase_base_GetAttr", (PyCFunction) _wrap_PyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18118 { (char *)"PyGridTableBase_base_SetAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18119 { (char *)"PyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18120 { (char *)"PyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18121 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18122 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18123 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18124 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18125 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18126 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18127 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18128 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18131 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18132 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18134 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18135 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18136 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18137 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18138 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18140 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18143 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18146 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18148 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18150 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18152 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18154 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18177 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18182 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18189 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18191 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18192 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18195 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18198 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18201 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18204 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18207 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18210 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18234 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18246 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18255 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18257 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18259 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18262 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18270 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18281 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18298 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18321 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18323 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18325 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18328 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18329 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18334 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18335 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18338 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18339 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18343 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18345 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18346 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18347 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18348 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18356 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18358 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18359 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18360 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18364 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18365 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18366 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18367 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18368 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18369 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18370 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18371 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18372 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18373 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18374 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18375 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18376 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18377 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18378 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18379 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18380 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18381 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18382 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18383 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18384 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18385 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18386 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18387 { NULL, NULL, 0, NULL }
18388 };
18389
18390
18391 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18392
18393 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18394 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18395 }
18396 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18397 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18398 }
18399 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18400 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18401 }
18402 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18403 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18404 }
18405 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18406 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18407 }
18408 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18409 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18410 }
18411 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18412 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18413 }
18414 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18415 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18416 }
18417 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18418 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18419 }
18420 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18421 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18422 }
18423 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18424 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18425 }
18426 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18427 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18428 }
18429 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18430 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18431 }
18432 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18433 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18434 }
18435 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18436 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18437 }
18438 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18439 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18440 }
18441 static void *_p_wxGridTo_p_wxPanel(void *x) {
18442 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18443 }
18444 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18445 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18446 }
18447 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18448 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18449 }
18450 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18451 return (void *)((wxPanel *) ((wxPyPanel *) x));
18452 }
18453 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18454 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18455 }
18456 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18457 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18458 }
18459 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18460 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18461 }
18462 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18463 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18464 }
18465 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18466 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18467 }
18468 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18469 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18470 }
18471 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18472 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18473 }
18474 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18475 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18476 }
18477 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18478 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18479 }
18480 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18481 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18482 }
18483 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18484 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18485 }
18486 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18487 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18488 }
18489 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18490 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18491 }
18492 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18493 return (void *)((wxWindow *) ((wxMenuBar *) x));
18494 }
18495 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18496 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18497 }
18498 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18499 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18500 }
18501 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18502 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18503 }
18504 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18505 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18506 }
18507 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18508 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18509 }
18510 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18511 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18512 }
18513 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18514 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18515 }
18516 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18517 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18518 }
18519 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18520 return (void *)((wxWindow *) ((wxPanel *) x));
18521 }
18522 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18523 return (void *)((wxWindow *) ((wxStatusBar *) x));
18524 }
18525 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18526 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18527 }
18528 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18529 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18530 }
18531 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18532 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18533 }
18534 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18535 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18536 }
18537 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18538 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18539 }
18540 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18541 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18542 }
18543 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18544 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18545 }
18546 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18547 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18548 }
18549 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18550 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18551 }
18552 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18553 return (void *)((wxWindow *) ((wxSashWindow *) x));
18554 }
18555 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18556 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18557 }
18558 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18559 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18560 }
18561 static void *_p_wxControlTo_p_wxWindow(void *x) {
18562 return (void *)((wxWindow *) ((wxControl *) x));
18563 }
18564 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18565 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18566 }
18567 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18568 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18569 }
18570 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18571 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18572 }
18573 static void *_p_wxGridTo_p_wxWindow(void *x) {
18574 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18575 }
18576 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18577 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18578 }
18579 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18580 return (void *)((wxWindow *) ((wxPyWindow *) x));
18581 }
18582 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18583 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18584 }
18585 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18586 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18587 }
18588 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18589 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18590 }
18591 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18592 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18593 }
18594 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18595 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18596 }
18597 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18598 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18599 }
18600 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18601 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18602 }
18603 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18604 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18605 }
18606 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18607 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18608 }
18609 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18610 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18611 }
18612 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18613 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18614 }
18615 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18616 return (void *)((wxControl *) ((wxControlWithItems *) x));
18617 }
18618 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18619 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18620 }
18621 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18622 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18623 }
18624 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18625 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18626 }
18627 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18628 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18629 }
18630 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18631 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18632 }
18633 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18634 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18635 }
18636 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18637 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18638 }
18639 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18640 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18641 }
18642 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18643 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18644 }
18645 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18646 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18647 }
18648 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18649 return (void *)((wxEvent *) ((wxPyEvent *) x));
18650 }
18651 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18652 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18653 }
18654 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18655 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18656 }
18657 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18658 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18659 }
18660 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18661 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18662 }
18663 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18664 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18665 }
18666 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18667 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18668 }
18669 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18670 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18671 }
18672 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18673 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18674 }
18675 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18676 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18677 }
18678 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18679 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18680 }
18681 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18682 return (void *)((wxEvent *) ((wxMoveEvent *) x));
18683 }
18684 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
18685 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18686 }
18687 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
18688 return (void *)((wxEvent *) ((wxPaintEvent *) x));
18689 }
18690 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
18691 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
18692 }
18693 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
18694 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
18695 }
18696 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
18697 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
18698 }
18699 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
18700 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
18701 }
18702 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
18703 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18704 }
18705 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
18706 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
18707 }
18708 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
18709 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18710 }
18711 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
18712 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18713 }
18714 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
18715 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
18716 }
18717 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
18718 return (void *)((wxEvent *) ((wxFocusEvent *) x));
18719 }
18720 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
18721 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
18722 }
18723 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
18724 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
18725 }
18726 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
18727 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18728 }
18729 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
18730 return (void *)((wxEvent *) ((wxShowEvent *) x));
18731 }
18732 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
18733 return (void *)((wxEvent *) ((wxCommandEvent *) x));
18734 }
18735 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
18736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
18737 }
18738 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
18739 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
18740 }
18741 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
18742 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
18743 }
18744 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
18745 return (void *)((wxEvent *) ((wxKeyEvent *) x));
18746 }
18747 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
18748 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
18749 }
18750 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
18751 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
18752 }
18753 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
18754 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
18755 }
18756 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
18757 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18758 }
18759 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
18760 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18761 }
18762 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
18763 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18764 }
18765 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
18766 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
18767 }
18768 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
18769 return (void *)((wxObject *) ((wxSizerItem *) x));
18770 }
18771 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
18772 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
18773 }
18774 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
18775 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
18776 }
18777 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
18778 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
18779 }
18780 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
18781 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
18782 }
18783 static void *_p_wxSizerTo_p_wxObject(void *x) {
18784 return (void *)((wxObject *) ((wxSizer *) x));
18785 }
18786 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
18787 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
18788 }
18789 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
18790 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
18791 }
18792 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
18793 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
18794 }
18795 static void *_p_wxEventTo_p_wxObject(void *x) {
18796 return (void *)((wxObject *) ((wxEvent *) x));
18797 }
18798 static void *_p_wxFontDataTo_p_wxObject(void *x) {
18799 return (void *)((wxObject *) ((wxFontData *) x));
18800 }
18801 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
18802 return (void *)((wxObject *) ((wxPrintData *) x));
18803 }
18804 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
18805 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
18806 }
18807 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
18808 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
18809 }
18810 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
18811 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
18812 }
18813 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
18814 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
18815 }
18816 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
18817 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
18818 }
18819 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
18820 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
18821 }
18822 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
18823 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
18824 }
18825 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
18826 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
18827 }
18828 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
18829 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
18830 }
18831 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
18832 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
18833 }
18834 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
18835 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
18836 }
18837 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
18838 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18839 }
18840 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
18841 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
18842 }
18843 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
18844 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18845 }
18846 static void *_p_wxGridEventTo_p_wxObject(void *x) {
18847 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18848 }
18849 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
18850 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18851 }
18852 static void *_p_wxControlTo_p_wxObject(void *x) {
18853 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
18854 }
18855 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
18856 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
18857 }
18858 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
18859 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18860 }
18861 static void *_p_wxFSFileTo_p_wxObject(void *x) {
18862 return (void *)((wxObject *) ((wxFSFile *) x));
18863 }
18864 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
18865 return (void *)((wxObject *) ((wxFindReplaceData *) x));
18866 }
18867 static void *_p_wxGridTo_p_wxObject(void *x) {
18868 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18869 }
18870 static void *_p_wxPySizerTo_p_wxObject(void *x) {
18871 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
18872 }
18873 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
18874 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18875 }
18876 static void *_p_wxColourDataTo_p_wxObject(void *x) {
18877 return (void *)((wxObject *) ((wxColourData *) x));
18878 }
18879 static void *_p_wxPyEventTo_p_wxObject(void *x) {
18880 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
18881 }
18882 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
18883 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
18884 }
18885 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
18886 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
18887 }
18888 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
18889 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18890 }
18891 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
18892 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18893 }
18894 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
18895 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18896 }
18897 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
18898 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18899 }
18900 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
18901 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18902 }
18903 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
18904 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18905 }
18906 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
18907 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18908 }
18909 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
18910 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18911 }
18912 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
18913 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18914 }
18915 static void *_p_wxShowEventTo_p_wxObject(void *x) {
18916 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
18917 }
18918 static void *_p_wxPrinterTo_p_wxObject(void *x) {
18919 return (void *)((wxObject *) ((wxPrinter *) x));
18920 }
18921 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
18922 return (void *)((wxObject *) ((wxMenuItem *) x));
18923 }
18924 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
18925 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
18926 }
18927 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
18928 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
18929 }
18930 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
18931 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
18932 }
18933 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
18934 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
18935 }
18936 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
18937 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
18938 }
18939 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
18940 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
18941 }
18942 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
18943 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
18944 }
18945 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
18946 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
18947 }
18948 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
18949 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18950 }
18951 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
18952 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
18953 }
18954 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
18955 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
18956 }
18957 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
18958 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
18959 }
18960 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
18961 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
18962 }
18963 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
18964 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
18965 }
18966 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
18967 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
18968 }
18969 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
18970 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
18971 }
18972 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
18973 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
18974 }
18975 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
18976 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
18977 }
18978 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
18979 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
18980 }
18981 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
18982 return (void *)((wxObject *) ((wxImageHandler *) x));
18983 }
18984 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
18985 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
18986 }
18987 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
18988 return (void *)((wxObject *) ((wxEvtHandler *) x));
18989 }
18990 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
18991 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
18992 }
18993 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
18994 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18995 }
18996 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
18997 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18998 }
18999 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
19000 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19001 }
19002 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
19003 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
19004 }
19005 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
19006 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19007 }
19008 static void *_p_wxImageTo_p_wxObject(void *x) {
19009 return (void *)((wxObject *) ((wxImage *) x));
19010 }
19011 static void *_p_wxFrameTo_p_wxObject(void *x) {
19012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19013 }
19014 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
19015 return (void *)((wxObject *) ((wxPyPrintout *) x));
19016 }
19017 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19018 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19019 }
19020 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19021 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19022 }
19023 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19024 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19025 }
19026 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19027 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19028 }
19029 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19030 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19031 }
19032 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19033 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19034 }
19035 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19036 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19037 }
19038 static void *_p_wxWindowTo_p_wxObject(void *x) {
19039 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19040 }
19041 static void *_p_wxMenuTo_p_wxObject(void *x) {
19042 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19043 }
19044 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19045 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19046 }
19047 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19048 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19049 }
19050 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19051 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19052 }
19053 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19054 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19055 }
19056 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19057 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19058 }
19059 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19060 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19061 }
19062 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19063 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19064 }
19065 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19066 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19067 }
19068 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19069 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19070 }
19071 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19072 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19073 }
19074 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19075 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19076 }
19077 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19078 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19079 }
19080 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19081 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19082 }
19083 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19084 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19085 }
19086 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19087 return (void *)((wxObject *) ((wxPrintPreview *) x));
19088 }
19089 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19090 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19091 }
19092 static void *_p_wxPanelTo_p_wxObject(void *x) {
19093 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19094 }
19095 static void *_p_wxDialogTo_p_wxObject(void *x) {
19096 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19097 }
19098 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19099 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19100 }
19101 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19102 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19103 }
19104 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19105 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19106 }
19107 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19108 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19109 }
19110 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19111 return (void *)((wxObject *) ((wxPrintDialog *) x));
19112 }
19113 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19114 return (void *)((wxObject *) ((wxFileSystem *) x));
19115 }
19116 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19117 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19118 }
19119 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19120 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19121 }
19122 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19123 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19124 }
19125 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19126 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19127 }
19128 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19129 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19130 }
19131 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19132 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19133 }
19134 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19135 return (void *)((wxObject *) ((wxGridTableBase *) x));
19136 }
19137 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19138 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19139 }
19140 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19141 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19142 }
19143 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19144 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19145 }
19146 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19147 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19148 }
19149 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19150 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19151 }
19152 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19153 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19154 }
19155 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19156 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19157 }
19158 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19159 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19160 }
19161 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19162 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19163 }
19164 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19165 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19166 }
19167 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19168 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19169 }
19170 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19171 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19172 }
19173 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19174 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19175 }
19176 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19177 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19178 }
19179 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19180 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19181 }
19182 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19183 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19184 }
19185 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19186 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19187 }
19188 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19189 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19190 }
19191 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19192 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19193 }
19194 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19195 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19196 }
19197 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19198 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19199 }
19200 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19201 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19202 }
19203 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19204 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19205 }
19206 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19207 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19208 }
19209 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19210 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19211 }
19212 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19213 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19214 }
19215 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19216 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19217 }
19218 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19219 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19220 }
19221 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19222 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19223 }
19224 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19225 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19226 }
19227 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19228 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19229 }
19230 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19231 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19232 }
19233 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19234 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19235 }
19236 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19237 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19238 }
19239 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19240 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19241 }
19242 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19243 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19244 }
19245 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19246 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19247 }
19248 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19249 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19250 }
19251 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19252 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19253 }
19254 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19255 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19256 }
19257 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19258 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19259 }
19260 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19261 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19262 }
19263 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19264 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19265 }
19266 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19267 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19268 }
19269 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19270 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19271 }
19272 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19273 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19274 }
19275 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19276 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19277 }
19278 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19279 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19280 }
19281 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19282 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19283 }
19284 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19285 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19286 }
19287 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19288 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19289 }
19290 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19291 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19292 }
19293 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19294 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19295 }
19296 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19297 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19298 }
19299 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19300 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19301 }
19302 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19303 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19304 }
19305 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19306 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19307 }
19308 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19309 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19310 }
19311 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19312 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19313 }
19314 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19315 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19316 }
19317 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19318 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19319 }
19320 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19321 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19322 }
19323 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19324 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19325 }
19326 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19327 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19328 }
19329 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19330 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19331 }
19332 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19333 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19334 }
19335 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19336 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19337 }
19338 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19339 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19340 }
19341 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19342 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19343 }
19344 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19345 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19346 }
19347 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19348 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19349 }
19350 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19351 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19352 }
19353 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19354 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19355 }
19356 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19357 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19358 }
19359 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19360 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19361 }
19362 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19363 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19364 }
19365 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19366 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19367 }
19368 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19369 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19370 }
19371 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19372 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19373 }
19374 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19375 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19376 }
19377 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19378 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19379 }
19380 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19381 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19382 }
19383 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19384 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19385 }
19386 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19387 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19388 }
19389 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19390 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19391 }
19392 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19393 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19394 }
19395 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19396 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19397 }
19398 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19399 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19400 }
19401 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19402 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19403 }
19404 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19405 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19406 }
19407 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19408 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19409 }
19410 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19411 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19412 }
19413 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19414 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19415 }
19416 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}};
19417 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}};
19418 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}};
19419 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}};
19420 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}};
19421 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}};
19422 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}};
19423 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}};
19424 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}};
19425 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}};
19426 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}};
19427 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}};
19428 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}};
19429 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}};
19430 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}};
19431 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}};
19432 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}};
19433 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}};
19434 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}};
19435 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}};
19436 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}};
19437 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}};
19438 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}};
19439 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}};
19440 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}};
19441 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}};
19442 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}};
19443 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}};
19444 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_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}};
19445 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}};
19446 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}};
19447 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}};
19448 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}};
19449 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}};
19450 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}};
19451 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}};
19452 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}};
19453 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}};
19454 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}};
19455 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}};
19456 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}};
19457 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}};
19458 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}};
19459 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}};
19460 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}};
19461 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}};
19462 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}};
19463 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}};
19464 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}};
19465 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}};
19466 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}};
19467 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}};
19468 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}};
19469 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}};
19470 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}};
19471 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}};
19472 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}};
19473 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}};
19474 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}};
19475 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}};
19476 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}};
19477 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}};
19478
19479 static swig_type_info *swig_types_initial[] = {
19480 _swigt__p_wxGridCellNumberRenderer,
19481 _swigt__p_wxPyGridCellRenderer,
19482 _swigt__p_wxGridCellRenderer,
19483 _swigt__p_wxGridCellStringRenderer,
19484 _swigt__p_wxGridCellAttr,
19485 _swigt__p_wxGridCellFloatRenderer,
19486 _swigt__p_wxGridCellBoolRenderer,
19487 _swigt__p_wxGridCellDateTimeRenderer,
19488 _swigt__p_wxGridCellEnumRenderer,
19489 _swigt__p_wxGridCellAutoWrapStringRenderer,
19490 _swigt__p_wxColour,
19491 _swigt__p_wxDC,
19492 _swigt__p_form_ops_t,
19493 _swigt__p_wxDuplexMode,
19494 _swigt__p_wxGridTableMessage,
19495 _swigt__p_wxGrid,
19496 _swigt__p_wxVisualAttributes,
19497 _swigt__p_char,
19498 _swigt__p_wxPanel,
19499 _swigt__p_wxNotifyEvent,
19500 _swigt__p_wxGridRangeSelectEvent,
19501 _swigt__p_wxSize,
19502 _swigt__p_wxGridCellCoords,
19503 _swigt__p_wxScrolledWindow,
19504 _swigt__p_wxWindow,
19505 _swigt__p_wxFont,
19506 _swigt__p_wxControl,
19507 _swigt__p_wxEvent,
19508 _swigt__p_wxObject,
19509 _swigt__p_wxGridSizeEvent,
19510 _swigt__p_wxRect,
19511 _swigt__p_long,
19512 _swigt__p_wxPaperSize,
19513 _swigt__p_unsigned_int,
19514 _swigt__unsigned_int,
19515 _swigt__p_wxString,
19516 _swigt__p_wxEvtHandler,
19517 _swigt__p_wxPoint,
19518 _swigt__p_wxGridEvent,
19519 _swigt__p_wxGridEditorCreatedEvent,
19520 _swigt__p_wxGridTableBase,
19521 _swigt__p_wxGridCellEditor,
19522 _swigt__p_wxGridCellTextEditor,
19523 _swigt__p_wxPyGridCellEditor,
19524 _swigt__p_wxGridCellNumberEditor,
19525 _swigt__p_wxGridCellFloatEditor,
19526 _swigt__p_wxGridCellBoolEditor,
19527 _swigt__p_wxPyGridTableBase,
19528 _swigt__p_wxGridStringTable,
19529 _swigt__p_unsigned_char,
19530 _swigt__std__ptrdiff_t,
19531 _swigt__ptrdiff_t,
19532 _swigt__p_wxArrayString,
19533 _swigt__p_wxCommandEvent,
19534 _swigt__p_int,
19535 _swigt__p_wxGridCellAttrProvider,
19536 _swigt__p_wxGridCellChoiceEditor,
19537 _swigt__p_wxKeyEvent,
19538 _swigt__p_wxGridCellEnumEditor,
19539 _swigt__p_wxGridCellAutoWrapStringEditor,
19540 _swigt__p_wxPyGridCellAttrProvider,
19541 _swigt__p_unsigned_long,
19542 0
19543 };
19544
19545
19546 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
19547
19548 static swig_const_info swig_const_table[] = {
19549 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19550 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
19551 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19552 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
19553 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
19554 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19555 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19556 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
19557 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
19558 {0, 0, 0, 0.0, 0, 0}};
19559
19560 #ifdef __cplusplus
19561 }
19562 #endif
19563
19564
19565 #ifdef __cplusplus
19566 extern "C" {
19567 #endif
19568
19569 /* Python-specific SWIG API */
19570 #define SWIG_newvarlink() SWIG_Python_newvarlink()
19571 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
19572 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
19573
19574 /* -----------------------------------------------------------------------------
19575 * global variable support code.
19576 * ----------------------------------------------------------------------------- */
19577
19578 typedef struct swig_globalvar {
19579 char *name; /* Name of global variable */
19580 PyObject *(*get_attr)(); /* Return the current value */
19581 int (*set_attr)(PyObject *); /* Set the value */
19582 struct swig_globalvar *next;
19583 } swig_globalvar;
19584
19585 typedef struct swig_varlinkobject {
19586 PyObject_HEAD
19587 swig_globalvar *vars;
19588 } swig_varlinkobject;
19589
19590 static PyObject *
19591 swig_varlink_repr(swig_varlinkobject *v) {
19592 v = v;
19593 return PyString_FromString("<Swig global variables>");
19594 }
19595
19596 static int
19597 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
19598 swig_globalvar *var;
19599 flags = flags;
19600 fprintf(fp,"Swig global variables { ");
19601 for (var = v->vars; var; var=var->next) {
19602 fprintf(fp,"%s", var->name);
19603 if (var->next) fprintf(fp,", ");
19604 }
19605 fprintf(fp," }\n");
19606 return 0;
19607 }
19608
19609 static PyObject *
19610 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
19611 swig_globalvar *var = v->vars;
19612 while (var) {
19613 if (strcmp(var->name,n) == 0) {
19614 return (*var->get_attr)();
19615 }
19616 var = var->next;
19617 }
19618 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19619 return NULL;
19620 }
19621
19622 static int
19623 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
19624 swig_globalvar *var = v->vars;
19625 while (var) {
19626 if (strcmp(var->name,n) == 0) {
19627 return (*var->set_attr)(p);
19628 }
19629 var = var->next;
19630 }
19631 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19632 return 1;
19633 }
19634
19635 static PyTypeObject varlinktype = {
19636 PyObject_HEAD_INIT(0)
19637 0, /* Number of items in variable part (ob_size) */
19638 (char *)"swigvarlink", /* Type name (tp_name) */
19639 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
19640 0, /* Itemsize (tp_itemsize) */
19641 0, /* Deallocator (tp_dealloc) */
19642 (printfunc) swig_varlink_print, /* Print (tp_print) */
19643 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
19644 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
19645 0, /* tp_compare */
19646 (reprfunc) swig_varlink_repr, /* tp_repr */
19647 0, /* tp_as_number */
19648 0, /* tp_as_sequence */
19649 0, /* tp_as_mapping */
19650 0, /* tp_hash */
19651 0, /* tp_call */
19652 0, /* tp_str */
19653 0, /* tp_getattro */
19654 0, /* tp_setattro */
19655 0, /* tp_as_buffer */
19656 0, /* tp_flags */
19657 0, /* tp_doc */
19658 #if PY_VERSION_HEX >= 0x02000000
19659 0, /* tp_traverse */
19660 0, /* tp_clear */
19661 #endif
19662 #if PY_VERSION_HEX >= 0x02010000
19663 0, /* tp_richcompare */
19664 0, /* tp_weaklistoffset */
19665 #endif
19666 #if PY_VERSION_HEX >= 0x02020000
19667 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
19668 #endif
19669 #if PY_VERSION_HEX >= 0x02030000
19670 0, /* tp_del */
19671 #endif
19672 #ifdef COUNT_ALLOCS
19673 0,0,0,0 /* tp_alloc -> tp_next */
19674 #endif
19675 };
19676
19677 /* Create a variable linking object for use later */
19678 static PyObject *
19679 SWIG_Python_newvarlink(void) {
19680 swig_varlinkobject *result = 0;
19681 result = PyMem_NEW(swig_varlinkobject,1);
19682 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
19683 result->ob_type = &varlinktype;
19684 result->vars = 0;
19685 result->ob_refcnt = 0;
19686 Py_XINCREF((PyObject *) result);
19687 return ((PyObject*) result);
19688 }
19689
19690 static void
19691 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
19692 swig_varlinkobject *v;
19693 swig_globalvar *gv;
19694 v= (swig_varlinkobject *) p;
19695 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
19696 gv->name = (char *) malloc(strlen(name)+1);
19697 strcpy(gv->name,name);
19698 gv->get_attr = get_attr;
19699 gv->set_attr = set_attr;
19700 gv->next = v->vars;
19701 v->vars = gv;
19702 }
19703
19704 /* -----------------------------------------------------------------------------
19705 * constants/methods manipulation
19706 * ----------------------------------------------------------------------------- */
19707
19708 /* Install Constants */
19709 static void
19710 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
19711 PyObject *obj = 0;
19712 size_t i;
19713 for (i = 0; constants[i].type; i++) {
19714 switch(constants[i].type) {
19715 case SWIG_PY_INT:
19716 obj = PyInt_FromLong(constants[i].lvalue);
19717 break;
19718 case SWIG_PY_FLOAT:
19719 obj = PyFloat_FromDouble(constants[i].dvalue);
19720 break;
19721 case SWIG_PY_STRING:
19722 if (constants[i].pvalue) {
19723 obj = PyString_FromString((char *) constants[i].pvalue);
19724 } else {
19725 Py_INCREF(Py_None);
19726 obj = Py_None;
19727 }
19728 break;
19729 case SWIG_PY_POINTER:
19730 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
19731 break;
19732 case SWIG_PY_BINARY:
19733 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
19734 break;
19735 default:
19736 obj = 0;
19737 break;
19738 }
19739 if (obj) {
19740 PyDict_SetItemString(d,constants[i].name,obj);
19741 Py_DECREF(obj);
19742 }
19743 }
19744 }
19745
19746 /* -----------------------------------------------------------------------------*/
19747 /* Fix SwigMethods to carry the callback ptrs when needed */
19748 /* -----------------------------------------------------------------------------*/
19749
19750 static void
19751 SWIG_Python_FixMethods(PyMethodDef *methods,
19752 swig_const_info *const_table,
19753 swig_type_info **types,
19754 swig_type_info **types_initial) {
19755 size_t i;
19756 for (i = 0; methods[i].ml_name; ++i) {
19757 char *c = methods[i].ml_doc;
19758 if (c && (c = strstr(c, "swig_ptr: "))) {
19759 int j;
19760 swig_const_info *ci = 0;
19761 char *name = c + 10;
19762 for (j = 0; const_table[j].type; j++) {
19763 if (strncmp(const_table[j].name, name,
19764 strlen(const_table[j].name)) == 0) {
19765 ci = &(const_table[j]);
19766 break;
19767 }
19768 }
19769 if (ci) {
19770 size_t shift = (ci->ptype) - types;
19771 swig_type_info *ty = types_initial[shift];
19772 size_t ldoc = (c - methods[i].ml_doc);
19773 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
19774 char *ndoc = (char*)malloc(ldoc + lptr + 10);
19775 char *buff = ndoc;
19776 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
19777 strncpy(buff, methods[i].ml_doc, ldoc);
19778 buff += ldoc;
19779 strncpy(buff, "swig_ptr: ", 10);
19780 buff += 10;
19781 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
19782 methods[i].ml_doc = ndoc;
19783 }
19784 }
19785 }
19786 }
19787
19788 /* -----------------------------------------------------------------------------*
19789 * Initialize type list
19790 * -----------------------------------------------------------------------------*/
19791
19792 #if PY_MAJOR_VERSION < 2
19793 /* PyModule_AddObject function was introduced in Python 2.0. The following function
19794 is copied out of Python/modsupport.c in python version 2.3.4 */
19795 static int
19796 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
19797 {
19798 PyObject *dict;
19799 if (!PyModule_Check(m)) {
19800 PyErr_SetString(PyExc_TypeError,
19801 "PyModule_AddObject() needs module as first arg");
19802 return -1;
19803 }
19804 if (!o) {
19805 PyErr_SetString(PyExc_TypeError,
19806 "PyModule_AddObject() needs non-NULL value");
19807 return -1;
19808 }
19809
19810 dict = PyModule_GetDict(m);
19811 if (dict == NULL) {
19812 /* Internal error -- modules must have a dict! */
19813 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
19814 PyModule_GetName(m));
19815 return -1;
19816 }
19817 if (PyDict_SetItemString(dict, name, o))
19818 return -1;
19819 Py_DECREF(o);
19820 return 0;
19821 }
19822 #endif
19823
19824 static swig_type_info **
19825 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
19826 static PyMethodDef swig_empty_runtime_method_table[] = {
19827 {
19828 NULL, NULL, 0, NULL
19829 }
19830 };/* Sentinel */
19831
19832 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
19833 swig_empty_runtime_method_table);
19834 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
19835 if (pointer && module) {
19836 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
19837 }
19838 return type_list_handle;
19839 }
19840
19841 static swig_type_info **
19842 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
19843 swig_type_info **type_pointer;
19844
19845 /* first check if module already created */
19846 type_pointer = SWIG_Python_GetTypeListHandle();
19847 if (type_pointer) {
19848 return type_pointer;
19849 } else {
19850 /* create a new module and variable */
19851 return SWIG_Python_SetTypeListHandle(type_list_handle);
19852 }
19853 }
19854
19855 #ifdef __cplusplus
19856 }
19857 #endif
19858
19859 /* -----------------------------------------------------------------------------*
19860 * Partial Init method
19861 * -----------------------------------------------------------------------------*/
19862
19863 #ifdef SWIG_LINK_RUNTIME
19864 #ifdef __cplusplus
19865 extern "C"
19866 #endif
19867 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
19868 #endif
19869
19870 #ifdef __cplusplus
19871 extern "C"
19872 #endif
19873 SWIGEXPORT(void) SWIG_init(void) {
19874 static PyObject *SWIG_globals = 0;
19875 static int typeinit = 0;
19876 PyObject *m, *d;
19877 int i;
19878 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
19879
19880 /* Fix SwigMethods to carry the callback ptrs when needed */
19881 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
19882
19883 m = Py_InitModule((char *) SWIG_name, SwigMethods);
19884 d = PyModule_GetDict(m);
19885
19886 if (!typeinit) {
19887 #ifdef SWIG_LINK_RUNTIME
19888 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
19889 #else
19890 # ifndef SWIG_STATIC_RUNTIME
19891 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
19892 # endif
19893 #endif
19894 for (i = 0; swig_types_initial[i]; i++) {
19895 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
19896 }
19897 typeinit = 1;
19898 }
19899 SWIG_InstallConstants(d,swig_const_table);
19900
19901 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
19902 SWIG_addvarlink(SWIG_globals,(char*)"DateTimeFormatStr",_wrap_DateTimeFormatStr_get, _wrap_DateTimeFormatStr_set);
19903 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
19904 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
19905 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
19906 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
19907 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
19908 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
19909 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
19910 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
19911 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
19912 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
19913 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
19914 {
19915 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_ROWS)));
19916 }
19917 {
19918 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_COLS)));
19919 }
19920 {
19921 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_HEIGHT)));
19922 }
19923 {
19924 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_COL_WIDTH)));
19925 }
19926 {
19927 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
19928 }
19929 {
19930 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
19931 }
19932 {
19933 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int((int)(wxGRID_LABEL_EDGE_ZONE)));
19934 }
19935 {
19936 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_MIN_ROW_HEIGHT)));
19937 }
19938 {
19939 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int((int)(wxGRID_MIN_COL_WIDTH)));
19940 }
19941 {
19942 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
19943 }
19944 {
19945 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int((int)(wxGridCellAttr::Any)));
19946 }
19947 {
19948 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int((int)(wxGridCellAttr::Default)));
19949 }
19950 {
19951 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int((int)(wxGridCellAttr::Cell)));
19952 }
19953 {
19954 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int((int)(wxGridCellAttr::Row)));
19955 }
19956 {
19957 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int((int)(wxGridCellAttr::Col)));
19958 }
19959 {
19960 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int((int)(wxGridCellAttr::Merged)));
19961 }
19962 {
19963 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
19964 }
19965 {
19966 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
19967 }
19968 {
19969 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
19970 }
19971 {
19972 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
19973 }
19974 {
19975 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
19976 }
19977 {
19978 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
19979 }
19980 {
19981 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
19982 }
19983 {
19984 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
19985 }
19986 {
19987 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int((int)(wxGrid::wxGridSelectCells)));
19988 }
19989 {
19990 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int((int)(wxGrid::wxGridSelectRows)));
19991 }
19992 {
19993 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int((int)(wxGrid::wxGridSelectColumns)));
19994 }
19995 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
19996 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
19997 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
19998 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
19999 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
20000 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
20001 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
20002 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
20003 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
20004 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
20005 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
20006 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
20007 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
20008 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
20009 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
20010 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
20011 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
20012
20013
20014 }
20015
wxWidgets (Impactor)