]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[0]
1343 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[1]
1344 #define SWIGTYPE_p_wxGridCellRenderer swig_types[2]
1345 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[3]
1346 #define SWIGTYPE_p_wxGridCellAttr swig_types[4]
1347 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[5]
1348 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[6]
1349 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[7]
1350 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[8]
1351 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[9]
1352 #define SWIGTYPE_p_wxColour swig_types[10]
1353 #define SWIGTYPE_p_wxDC swig_types[11]
1354 #define SWIGTYPE_p_form_ops_t swig_types[12]
1355 #define SWIGTYPE_p_wxDuplexMode swig_types[13]
1356 #define SWIGTYPE_p_wxGridTableMessage swig_types[14]
1357 #define SWIGTYPE_p_wxGrid swig_types[15]
1358 #define SWIGTYPE_p_wxVisualAttributes swig_types[16]
1359 #define SWIGTYPE_p_char swig_types[17]
1360 #define SWIGTYPE_p_wxPanel swig_types[18]
1361 #define SWIGTYPE_p_wxNotifyEvent swig_types[19]
1362 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[20]
1363 #define SWIGTYPE_p_wxSize swig_types[21]
1364 #define SWIGTYPE_p_wxGridCellCoords swig_types[22]
1365 #define SWIGTYPE_p_wxScrolledWindow swig_types[23]
1366 #define SWIGTYPE_p_wxWindow swig_types[24]
1367 #define SWIGTYPE_p_wxFont swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxEvent swig_types[27]
1370 #define SWIGTYPE_p_wxObject swig_types[28]
1371 #define SWIGTYPE_p_wxGridSizeEvent swig_types[29]
1372 #define SWIGTYPE_p_wxRect swig_types[30]
1373 #define SWIGTYPE_p_long swig_types[31]
1374 #define SWIGTYPE_p_wxPaperSize swig_types[32]
1375 #define SWIGTYPE_p_unsigned_int swig_types[33]
1376 #define SWIGTYPE_unsigned_int swig_types[34]
1377 #define SWIGTYPE_p_wxString swig_types[35]
1378 #define SWIGTYPE_p_wxEvtHandler swig_types[36]
1379 #define SWIGTYPE_p_wxPoint swig_types[37]
1380 #define SWIGTYPE_p_wxGridEvent swig_types[38]
1381 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[39]
1382 #define SWIGTYPE_p_wxGridTableBase swig_types[40]
1383 #define SWIGTYPE_p_wxGridCellEditor swig_types[41]
1384 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[42]
1385 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[43]
1386 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[44]
1387 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[45]
1388 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[46]
1389 #define SWIGTYPE_p_wxPyGridTableBase swig_types[47]
1390 #define SWIGTYPE_p_wxGridStringTable swig_types[48]
1391 #define SWIGTYPE_p_unsigned_char swig_types[49]
1392 #define SWIGTYPE_std__ptrdiff_t swig_types[50]
1393 #define SWIGTYPE_ptrdiff_t swig_types[51]
1394 #define SWIGTYPE_p_wxArrayString swig_types[52]
1395 #define SWIGTYPE_p_wxCommandEvent swig_types[53]
1396 #define SWIGTYPE_p_int swig_types[54]
1397 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[55]
1398 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
1399 #define SWIGTYPE_p_wxKeyEvent swig_types[57]
1400 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[58]
1401 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[59]
1402 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[60]
1403 #define SWIGTYPE_p_unsigned_long swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _grid.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_grid
1413
1414 #define SWIG_name "_grid"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418 #include "wx/wxPython/printfw.h"
1419
1420 #include <wx/grid.h>
1421 #include <wx/generic/gridctrl.h>
1422
1423
1424 static const wxString wxPyEmptyString(wxEmptyString);
1425 static const wxString wxPyPanelNameStr(wxPanelNameStr);
1426 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
1427
1428
1429 #define wxPyMake_TEMPLATE(TYPE) \
1430 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
1431 PyObject* target = NULL; \
1432 if (source) { \
1433 /* Check if there is already a pointer to a Python object in the \
1434 OOR data that we can use. */ \
1435 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
1436 if (data) { \
1437 target = data->m_obj; \
1438 if (target) \
1439 Py_INCREF(target); \
1440 } \
1441 /* Otherwise make a new wrapper for it the old fashioned way and \
1442 give it the OOR treatment */ \
1443 if (! target) { \
1444 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
1445 if (target) \
1446 source->SetClientObject(new wxPyOORClientData(target)); \
1447 } \
1448 } else { /* source was NULL so return None. */ \
1449 Py_INCREF(Py_None); target = Py_None; \
1450 } \
1451 return target; \
1452 } \
1453
1454
1455 wxPyMake_TEMPLATE(wxGridCellRenderer)
1456 wxPyMake_TEMPLATE(wxGridCellEditor)
1457 wxPyMake_TEMPLATE(wxGridCellAttr)
1458 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
1459 wxPyMake_TEMPLATE(wxGridTableBase)
1460
1461
1462
1463 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
1464 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1465 wxGridCellAttr* rval = NULL; \
1466 bool found; \
1467 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1468 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1469 PyObject* ro; \
1470 wxGridCellAttr* ptr; \
1471 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
1472 if (ro) { \
1473 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
1474 rval = ptr; \
1475 Py_DECREF(ro); \
1476 } \
1477 } \
1478 wxPyEndBlockThreads(blocked); \
1479 if (! found) \
1480 rval = PCLASS::CBNAME(a, b, c); \
1481 return rval; \
1482 } \
1483 wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1484 return PCLASS::CBNAME(a, b, c); \
1485 }
1486
1487
1488
1489 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
1490 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
1491 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1492 bool found; \
1493 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1494 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1495 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
1496 Py_DECREF(obj); \
1497 } \
1498 wxPyEndBlockThreads(blocked); \
1499 if (! found) \
1500 PCLASS::CBNAME(attr, a, b); \
1501 } \
1502 void base_##CBNAME(wxGridCellAttr *attr, int a, int b) { \
1503 PCLASS::CBNAME(attr, a, b); \
1504 }
1505
1506
1507
1508 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
1509 void CBNAME(wxGridCellAttr *attr, int val) { \
1510 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1511 bool found; \
1512 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1513 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1514 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
1515 Py_DECREF(obj); \
1516 } \
1517 wxPyEndBlockThreads(blocked); \
1518 if (! found) \
1519 PCLASS::CBNAME(attr, val); \
1520 } \
1521 void base_##CBNAME(wxGridCellAttr *attr, int val) { \
1522 PCLASS::CBNAME(attr, val); \
1523 }
1524
1525
1526
1527 #define PYCALLBACK_INT__pure(CBNAME) \
1528 int CBNAME() { \
1529 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1530 int rval = 0; \
1531 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1532 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1533 wxPyEndBlockThreads(blocked); \
1534 return rval; \
1535 }
1536
1537
1538
1539 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
1540 bool CBNAME(int a, int b) { \
1541 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1542 bool rval = 0; \
1543 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1544 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
1545 wxPyEndBlockThreads(blocked); \
1546 return rval; \
1547 }
1548
1549
1550 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
1551 wxString CBNAME(int a, int b) { \
1552 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1553 wxString rval; \
1554 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1555 PyObject* ro; \
1556 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1557 if (ro) { \
1558 rval = Py2wxString(ro); \
1559 Py_DECREF(ro); \
1560 } \
1561 } \
1562 wxPyEndBlockThreads(blocked); \
1563 return rval; \
1564 }
1565
1566
1567 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
1568 void CBNAME(int a, int b, const wxString& c) { \
1569 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1570 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1571 PyObject* s = wx2PyString(c); \
1572 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1573 Py_DECREF(s); \
1574 } \
1575 wxPyEndBlockThreads(blocked); \
1576 }
1577
1578
1579 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
1580 wxString CBNAME(int a, int b) { \
1581 bool found; \
1582 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1583 wxString rval; \
1584 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1585 PyObject* ro; \
1586 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1587 if (ro) { \
1588 rval = Py2wxString(ro); \
1589 Py_DECREF(ro); \
1590 } \
1591 } \
1592 wxPyEndBlockThreads(blocked); \
1593 if (! found) \
1594 rval = PCLASS::CBNAME(a, b); \
1595 return rval; \
1596 } \
1597 wxString base_##CBNAME(int a, int b) { \
1598 return PCLASS::CBNAME(a, b); \
1599 }
1600
1601
1602 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
1603 bool CBNAME(int a, int b, const wxString& c) { \
1604 bool rval = 0; \
1605 bool found; \
1606 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1607 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1608 PyObject* s = wx2PyString(c); \
1609 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1610 Py_DECREF(s); \
1611 } \
1612 wxPyEndBlockThreads(blocked); \
1613 if (! found) \
1614 rval = PCLASS::CBNAME(a,b,c); \
1615 return rval; \
1616 } \
1617 bool base_##CBNAME(int a, int b, const wxString& c) { \
1618 return PCLASS::CBNAME(a,b,c); \
1619 }
1620
1621
1622
1623
1624 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
1625 long CBNAME(int a, int b) { \
1626 long rval; \
1627 bool found; \
1628 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1629 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1630 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1631 wxPyEndBlockThreads(blocked); \
1632 if (! found) \
1633 rval = PCLASS::CBNAME(a,b); \
1634 return rval; \
1635 } \
1636 long base_##CBNAME(int a, int b) { \
1637 return PCLASS::CBNAME(a,b); \
1638 }
1639
1640
1641
1642 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
1643 bool CBNAME(int a, int b) { \
1644 bool rval = 0; \
1645 bool found; \
1646 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1647 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1648 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1649 wxPyEndBlockThreads(blocked); \
1650 if (! found) \
1651 rval = PCLASS::CBNAME(a,b); \
1652 return rval; \
1653 } \
1654 bool base_##CBNAME(int a, int b) { \
1655 return PCLASS::CBNAME(a,b); \
1656 }
1657
1658
1659
1660 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
1661 double CBNAME(int a, int b) { \
1662 bool found; \
1663 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1664 double rval; \
1665 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1666 PyObject* ro; \
1667 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1668 if (ro) { \
1669 PyObject* str = PyObject_Str(ro); \
1670 rval = PyFloat_AsDouble(str); \
1671 Py_DECREF(ro); Py_DECREF(str); \
1672 } \
1673 } \
1674 wxPyEndBlockThreads(blocked); \
1675 if (! found) \
1676 rval = PCLASS::CBNAME(a, b); \
1677 return rval; \
1678 } \
1679 double base_##CBNAME(int a, int b) { \
1680 return PCLASS::CBNAME(a, b); \
1681 }
1682
1683
1684
1685 #define PYCALLBACK__(PCLASS, CBNAME) \
1686 void CBNAME() { \
1687 bool found; \
1688 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1689 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1690 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1691 wxPyEndBlockThreads(blocked); \
1692 if (! found) \
1693 PCLASS::CBNAME(); \
1694 } \
1695 void base_##CBNAME() { \
1696 PCLASS::CBNAME(); \
1697 }
1698
1699
1700
1701
1702 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
1703 bool CBNAME(size_t a, size_t b) { \
1704 bool rval = 0; \
1705 bool found; \
1706 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1707 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1708 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1709 wxPyEndBlockThreads(blocked); \
1710 if (! found) \
1711 rval = PCLASS::CBNAME(a,b); \
1712 return rval; \
1713 } \
1714 bool base_##CBNAME(size_t a, size_t b) { \
1715 return PCLASS::CBNAME(a,b); \
1716 }
1717
1718
1719
1720 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
1721 bool CBNAME(size_t a) { \
1722 bool rval = 0; \
1723 bool found; \
1724 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1725 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1726 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1727 wxPyEndBlockThreads(blocked); \
1728 if (! found) \
1729 rval = PCLASS::CBNAME(a); \
1730 return rval; \
1731 } \
1732 bool base_##CBNAME(size_t a) { \
1733 return PCLASS::CBNAME(a); \
1734 }
1735
1736
1737 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
1738 wxString CBNAME(int a) { \
1739 bool found; \
1740 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1741 wxString rval; \
1742 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1743 PyObject* ro; \
1744 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
1745 if (ro) { \
1746 rval = Py2wxString(ro); \
1747 Py_DECREF(ro); \
1748 } \
1749 } \
1750 wxPyEndBlockThreads(blocked); \
1751 if (! found) \
1752 rval = PCLASS::CBNAME(a); \
1753 return rval; \
1754 } \
1755 wxString base_##CBNAME(int a) { \
1756 return PCLASS::CBNAME(a); \
1757 }
1758
1759
1760 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
1761 void CBNAME(int a, const wxString& c) { \
1762 bool found; \
1763 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1764 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1765 PyObject* s = wx2PyString(c); \
1766 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
1767 Py_DECREF(s); \
1768 } \
1769 wxPyEndBlockThreads(blocked); \
1770 if (! found) \
1771 PCLASS::CBNAME(a,c); \
1772 } \
1773 void base_##CBNAME(int a, const wxString& c) { \
1774 PCLASS::CBNAME(a,c); \
1775 }
1776
1777
1778
1779
1780 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
1781 bool CBNAME() { \
1782 bool rval = 0; \
1783 bool found; \
1784 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1785 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1786 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1787 wxPyEndBlockThreads(blocked); \
1788 if (! found) \
1789 rval = PCLASS::CBNAME(); \
1790 return rval; \
1791 } \
1792 bool base_##CBNAME() { \
1793 return PCLASS::CBNAME(); \
1794 }
1795
1796
1797
1798 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
1799 void CBNAME(size_t a, int b) { \
1800 bool found; \
1801 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1802 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1803 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1804 wxPyEndBlockThreads(blocked); \
1805 if (! found) \
1806 PCLASS::CBNAME(a,b); \
1807 } \
1808 void base_##CBNAME(size_t a, int b) { \
1809 PCLASS::CBNAME(a,b); \
1810 }
1811
1812
1813
1814
1815 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
1816 void CBNAME(int a, int b, long c) { \
1817 bool found; \
1818 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1819 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1820 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1821 wxPyEndBlockThreads(blocked); \
1822 if (! found) \
1823 PCLASS::CBNAME(a,b,c); \
1824 } \
1825 void base_##CBNAME(int a, int b, long c) { \
1826 PCLASS::CBNAME(a,b,c); \
1827 }
1828
1829
1830
1831
1832 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
1833 void CBNAME(int a, int b, double c) { \
1834 bool found; \
1835 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1836 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1837 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
1838 wxPyEndBlockThreads(blocked); \
1839 if (! found) \
1840 PCLASS::CBNAME(a,b,c); \
1841 } \
1842 void base_##CBNAME(int a, int b, double c) { \
1843 PCLASS::CBNAME(a,b,c); \
1844 }
1845
1846
1847
1848 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
1849 void CBNAME(int a, int b, bool c) { \
1850 bool found; \
1851 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1852 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1853 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
1854 wxPyEndBlockThreads(blocked); \
1855 if (! found) \
1856 PCLASS::CBNAME(a,b,c); \
1857 } \
1858 void base_##CBNAME(int a, int b, bool c) { \
1859 PCLASS::CBNAME(a,b,c); \
1860 }
1861
1862
1863
1864
1865
1866
1867 SWIGINTERN PyObject *
1868 SWIG_FromCharPtr(const char* cptr)
1869 {
1870 if (cptr) {
1871 size_t size = strlen(cptr);
1872 if (size > INT_MAX) {
1873 return SWIG_NewPointerObj((char*)(cptr),
1874 SWIG_TypeQuery("char *"), 0);
1875 } else {
1876 if (size != 0) {
1877 return PyString_FromStringAndSize(cptr, size);
1878 } else {
1879 return PyString_FromString(cptr);
1880 }
1881 }
1882 }
1883 Py_INCREF(Py_None);
1884 return Py_None;
1885 }
1886
1887
1888 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
1889 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
1890 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
1891 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
1892 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
1893 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
1894 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
1895 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
1896 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
1897 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
1898
1899
1900 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1901 #define SWIG_From_int PyInt_FromLong
1902 /*@@*/
1903
1904 static void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
1905 if (!self->GetClientObject())
1906 self->SetClientObject(new wxPyOORClientData(_self));
1907 }
1908
1909 #include <limits.h>
1910
1911
1912 SWIGINTERN int
1913 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1914 const char *errmsg)
1915 {
1916 if (value < min_value) {
1917 if (errmsg) {
1918 PyErr_Format(PyExc_OverflowError,
1919 "value %ld is less than '%s' minimum %ld",
1920 value, errmsg, min_value);
1921 }
1922 return 0;
1923 } else if (value > max_value) {
1924 if (errmsg) {
1925 PyErr_Format(PyExc_OverflowError,
1926 "value %ld is greater than '%s' maximum %ld",
1927 value, errmsg, max_value);
1928 }
1929 return 0;
1930 }
1931 return 1;
1932 }
1933
1934
1935 SWIGINTERN int
1936 SWIG_AsVal_long(PyObject* obj, long* val)
1937 {
1938 if (PyNumber_Check(obj)) {
1939 if (val) *val = PyInt_AsLong(obj);
1940 return 1;
1941 }
1942 else {
1943 SWIG_type_error("number", obj);
1944 }
1945 return 0;
1946 }
1947
1948
1949 #if INT_MAX != LONG_MAX
1950 SWIGINTERN int
1951 SWIG_AsVal_int(PyObject *obj, int *val)
1952 {
1953 const char* errmsg = val ? "int" : (char*)0;
1954 long v;
1955 if (SWIG_AsVal_long(obj, &v)) {
1956 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1957 if (val) *val = (int)(v);
1958 return 1;
1959 } else {
1960 return 0;
1961 }
1962 } else {
1963 PyErr_Clear();
1964 }
1965 if (val) {
1966 SWIG_type_error(errmsg, obj);
1967 }
1968 return 0;
1969 }
1970 #else
1971 SWIGINTERNSHORT int
1972 SWIG_AsVal_int(PyObject *obj, int *val)
1973 {
1974 return SWIG_AsVal_long(obj,(long*)val);
1975 }
1976 #endif
1977
1978
1979 SWIGINTERNSHORT int
1980 SWIG_As_int(PyObject* obj)
1981 {
1982 int v;
1983 if (!SWIG_AsVal_int(obj, &v)) {
1984 /*
1985 this is needed to make valgrind/purify happier.
1986 */
1987 memset((void*)&v, 0, sizeof(int));
1988 }
1989 return v;
1990 }
1991
1992
1993 SWIGINTERN int
1994 SWIG_AsVal_bool(PyObject *obj, bool *val)
1995 {
1996 if (obj == Py_True) {
1997 if (val) *val = true;
1998 return 1;
1999 }
2000 if (obj == Py_False) {
2001 if (val) *val = false;
2002 return 1;
2003 }
2004 int res = 0;
2005 if (SWIG_AsVal_int(obj, &res)) {
2006 if (val) *val = res ? true : false;
2007 return 1;
2008 } else {
2009 PyErr_Clear();
2010 }
2011 if (val) {
2012 SWIG_type_error("bool", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERNSHORT bool
2019 SWIG_As_bool(PyObject* obj)
2020 {
2021 bool v;
2022 if (!SWIG_AsVal_bool(obj, &v)) {
2023 /*
2024 this is needed to make valgrind/purify happier.
2025 */
2026 memset((void*)&v, 0, sizeof(bool));
2027 }
2028 return v;
2029 }
2030
2031
2032 SWIGINTERNSHORT int
2033 SWIG_Check_int(PyObject* obj)
2034 {
2035 return SWIG_AsVal_int(obj, (int*)0);
2036 }
2037
2038
2039 SWIGINTERNSHORT int
2040 SWIG_Check_bool(PyObject* obj)
2041 {
2042 return SWIG_AsVal_bool(obj, (bool*)0);
2043 }
2044
2045
2046 class wxPyGridCellRenderer : public wxGridCellRenderer
2047 {
2048 public:
2049 wxPyGridCellRenderer() : wxGridCellRenderer() {};
2050
2051 // Implement Python callback aware virtual methods
2052 void Draw(wxGrid& grid, wxGridCellAttr& attr,
2053 wxDC& dc, const wxRect& rect,
2054 int row, int col, bool isSelected) {
2055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2056 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
2057 PyObject* go = wxPyMake_wxObject(&grid,false);
2058 PyObject* dco = wxPyMake_wxObject(&dc,false);
2059 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2060 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
2061
2062 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
2063 row, col, isSelected));
2064 Py_DECREF(go);
2065 Py_DECREF(ao);
2066 Py_DECREF(dco);
2067 Py_DECREF(ro);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 }
2071
2072 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
2073 int row, int col) {
2074 wxSize rval;
2075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2076 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
2077 PyObject* ro;
2078 wxSize* ptr;
2079 PyObject* go = wxPyMake_wxObject(&grid,false);
2080 PyObject* dco = wxPyMake_wxObject(&dc,false);
2081 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2082
2083 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
2084 go, ao, dco,
2085 row, col));
2086 Py_DECREF(go);
2087 Py_DECREF(ao);
2088 Py_DECREF(dco);
2089
2090 if (ro) {
2091 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
2092 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
2093 rval = *ptr;
2094 }
2095 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
2096 PyObject* o1 = PySequence_GetItem(ro, 0);
2097 PyObject* o2 = PySequence_GetItem(ro, 1);
2098 if (PyNumber_Check(o1) && PyNumber_Check(o2))
2099 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
2100 else
2101 PyErr_SetString(PyExc_TypeError, errmsg);
2102 Py_DECREF(o1);
2103 Py_DECREF(o2);
2104 }
2105 else {
2106 PyErr_SetString(PyExc_TypeError, errmsg);
2107 }
2108 Py_DECREF(ro);
2109 }
2110 }
2111 wxPyEndBlockThreads(blocked);
2112 return rval;
2113 }
2114
2115
2116 wxGridCellRenderer *Clone() const {
2117 wxGridCellRenderer* rval = NULL;
2118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2119 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2120 PyObject* ro;
2121 wxGridCellRenderer* ptr;
2122 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2123 if (ro) {
2124 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
2125 rval = ptr;
2126 Py_DECREF(ro);
2127 }
2128 }
2129 wxPyEndBlockThreads(blocked);
2130 return rval;
2131 }
2132
2133 DEC_PYCALLBACK__STRING(SetParameters);
2134
2135 PYPRIVATE;
2136 };
2137
2138 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
2139
2140
2141 static void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
2142 if (!self->GetClientObject())
2143 self->SetClientObject(new wxPyOORClientData(_self));
2144 }
2145
2146 class wxPyGridCellEditor : public wxGridCellEditor
2147 {
2148 public:
2149 wxPyGridCellEditor() : wxGridCellEditor() {}
2150
2151 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
2152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2153 if (wxPyCBH_findCallback(m_myInst, "Create")) {
2154 PyObject* po = wxPyMake_wxObject(parent,false);
2155 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
2156
2157 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
2158 Py_DECREF(po);
2159 Py_DECREF(eo);
2160 }
2161 wxPyEndBlockThreads(blocked);
2162 }
2163
2164
2165 void BeginEdit(int row, int col, wxGrid* grid) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
2168 PyObject* go = wxPyMake_wxObject(grid,false);
2169 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2170 Py_DECREF(go);
2171 }
2172 wxPyEndBlockThreads(blocked);
2173 }
2174
2175
2176 bool EndEdit(int row, int col, wxGrid* grid) {
2177 bool rv = false;
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
2180 PyObject* go = wxPyMake_wxObject(grid,false);
2181 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2182 Py_DECREF(go);
2183 }
2184 wxPyEndBlockThreads(blocked);
2185 return rv;
2186 }
2187
2188
2189 wxGridCellEditor* Clone() const {
2190 wxGridCellEditor* rval = NULL;
2191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2192 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2193 PyObject* ro;
2194 wxGridCellEditor* ptr;
2195 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2196 if (ro) {
2197 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
2198 rval = ptr;
2199 Py_DECREF(ro);
2200 }
2201 }
2202 wxPyEndBlockThreads(blocked);
2203 return rval;
2204 }
2205
2206
2207 void Show(bool show, wxGridCellAttr *attr) {
2208 bool found;
2209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2210 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
2211 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2212 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
2213 Py_DECREF(ao);
2214 }
2215 wxPyEndBlockThreads(blocked);
2216 if (! found)
2217 wxGridCellEditor::Show(show, attr);
2218 }
2219 void base_Show(bool show, wxGridCellAttr *attr) {
2220 wxGridCellEditor::Show(show, attr);
2221 }
2222
2223
2224 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2225 bool found;
2226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2227 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
2228 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2229 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
2230
2231 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
2232
2233 Py_DECREF(ro);
2234 Py_DECREF(ao);
2235 }
2236 wxPyEndBlockThreads(blocked);
2237 if (! found)
2238 wxGridCellEditor::PaintBackground(rectCell, attr);
2239 }
2240 void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2241 wxGridCellEditor::PaintBackground(rectCell, attr);
2242 }
2243
2244
2245 DEC_PYCALLBACK___pure(Reset);
2246 DEC_PYCALLBACK__constany(SetSize, wxRect);
2247 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
2248 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
2249 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
2250 DEC_PYCALLBACK__(StartingClick);
2251 DEC_PYCALLBACK__(Destroy);
2252 DEC_PYCALLBACK__STRING(SetParameters);
2253 DEC_PYCALLBACK_STRING__constpure(GetValue);
2254
2255 PYPRIVATE;
2256 };
2257
2258
2259 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
2260 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
2261 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
2262 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
2263 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
2264 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
2265 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
2266 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
2267 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
2268
2269
2270 static void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
2271 if (!self->GetClientObject())
2272 self->SetClientObject(new wxPyOORClientData(_self));
2273 }
2274
2275 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2276 PyObject* o2;
2277 PyObject* o3;
2278
2279 if (!target) {
2280 target = o;
2281 } else if (target == Py_None) {
2282 Py_DECREF(Py_None);
2283 target = o;
2284 } else {
2285 if (!PyTuple_Check(target)) {
2286 o2 = target;
2287 target = PyTuple_New(1);
2288 PyTuple_SetItem(target, 0, o2);
2289 }
2290 o3 = PyTuple_New(1);
2291 PyTuple_SetItem(o3, 0, o);
2292
2293 o2 = target;
2294 target = PySequence_Concat(o2, o3);
2295 Py_DECREF(o2);
2296 Py_DECREF(o3);
2297 }
2298 return target;
2299 }
2300
2301
2302 static void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
2303 if (!self->GetClientObject())
2304 self->SetClientObject(new wxPyOORClientData(_self));
2305 }
2306
2307 SWIGINTERN int
2308 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2309 {
2310 long v = 0;
2311 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2312 SWIG_type_error("unsigned number", obj);
2313 }
2314 else if (val)
2315 *val = (unsigned long)v;
2316 return 1;
2317 }
2318
2319
2320 SWIGINTERNSHORT unsigned long
2321 SWIG_As_unsigned_SS_long(PyObject* obj)
2322 {
2323 unsigned long v;
2324 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2325 /*
2326 this is needed to make valgrind/purify happier.
2327 */
2328 memset((void*)&v, 0, sizeof(unsigned long));
2329 }
2330 return v;
2331 }
2332
2333
2334 SWIGINTERNSHORT int
2335 SWIG_Check_unsigned_SS_long(PyObject* obj)
2336 {
2337 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2338 }
2339
2340
2341 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
2342 {
2343 public:
2344 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
2345
2346 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
2347 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
2348 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
2349 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
2350
2351 PYPRIVATE;
2352 };
2353
2354 static void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
2355 if (!self->GetClientObject())
2356 self->SetClientObject(new wxPyOORClientData(_self));
2357 }
2358
2359 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2360 #define SWIG_From_long PyInt_FromLong
2361 /*@@*/
2362
2363
2364 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2365 #define SWIG_From_double PyFloat_FromDouble
2366 /*@@*/
2367
2368
2369 SWIGINTERNSHORT long
2370 SWIG_As_long(PyObject* obj)
2371 {
2372 long v;
2373 if (!SWIG_AsVal_long(obj, &v)) {
2374 /*
2375 this is needed to make valgrind/purify happier.
2376 */
2377 memset((void*)&v, 0, sizeof(long));
2378 }
2379 return v;
2380 }
2381
2382
2383 SWIGINTERNSHORT int
2384 SWIG_Check_long(PyObject* obj)
2385 {
2386 return SWIG_AsVal_long(obj, (long*)0);
2387 }
2388
2389
2390 SWIGINTERN int
2391 SWIG_AsVal_double(PyObject *obj, double* val)
2392 {
2393 if (PyNumber_Check(obj)) {
2394 if (val) *val = PyFloat_AsDouble(obj);
2395 return 1;
2396 }
2397 else {
2398 SWIG_type_error("number", obj);
2399 }
2400 return 0;
2401 }
2402
2403
2404 SWIGINTERNSHORT double
2405 SWIG_As_double(PyObject* obj)
2406 {
2407 double v;
2408 if (!SWIG_AsVal_double(obj, &v)) {
2409 /*
2410 this is needed to make valgrind/purify happier.
2411 */
2412 memset((void*)&v, 0, sizeof(double));
2413 }
2414 return v;
2415 }
2416
2417
2418 SWIGINTERNSHORT int
2419 SWIG_Check_double(PyObject* obj)
2420 {
2421 return SWIG_AsVal_double(obj, (double*)0);
2422 }
2423
2424
2425 class wxPyGridTableBase : public wxGridTableBase
2426 {
2427 public:
2428 wxPyGridTableBase() : wxGridTableBase() {}
2429
2430 PYCALLBACK_INT__pure(GetNumberRows);
2431 PYCALLBACK_INT__pure(GetNumberCols);
2432 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
2433 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
2434 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
2435 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
2436 PYCALLBACK__(wxGridTableBase, Clear);
2437 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
2438 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
2439 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
2440 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
2441 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
2442 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
2443 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
2444 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
2445 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
2446 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
2447 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
2448 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
2449 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
2450 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
2451 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
2452
2453
2454 wxString GetValue(int row, int col) {
2455 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2456 wxString rval;
2457 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2458 PyObject* ro;
2459 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
2460 if (ro) {
2461 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
2462 PyObject* old = ro;
2463 ro = PyObject_Str(ro);
2464 Py_DECREF(old);
2465 }
2466 rval = Py2wxString(ro);
2467 Py_DECREF(ro);
2468 }
2469 }
2470 wxPyEndBlockThreads(blocked);
2471 return rval;
2472 }
2473
2474 void SetValue(int row, int col, const wxString& val) {
2475 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2476 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2477 PyObject* s = wx2PyString(val);
2478 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
2479 Py_DECREF(s);
2480 }
2481 wxPyEndBlockThreads(blocked);
2482 }
2483
2484
2485 // Map the Get/Set methods for the standard non-string types to
2486 // the GetValue and SetValue python methods.
2487 long GetValueAsLong( int row, int col ) {
2488 long rval = 0;
2489 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2490 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2491 PyObject* ro;
2492 PyObject* num;
2493 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2494 if (ro && PyNumber_Check(ro)) {
2495 num = PyNumber_Int(ro);
2496 if (num) {
2497 rval = PyInt_AsLong(num);
2498 Py_DECREF(num);
2499 }
2500 Py_DECREF(ro);
2501 }
2502 }
2503 wxPyEndBlockThreads(blocked);
2504 return rval;
2505 }
2506
2507 double GetValueAsDouble( int row, int col ) {
2508 double rval = 0.0;
2509 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2510 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2511 PyObject* ro;
2512 PyObject* num;
2513 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2514 if (ro && PyNumber_Check(ro)) {
2515 num = PyNumber_Float(ro);
2516 if (num) {
2517 rval = PyFloat_AsDouble(num);
2518 Py_DECREF(num);
2519 }
2520 Py_DECREF(ro);
2521 }
2522 }
2523 wxPyEndBlockThreads(blocked);
2524 return rval;
2525 }
2526
2527 bool GetValueAsBool( int row, int col ) {
2528 return (bool)GetValueAsLong(row, col);
2529 }
2530
2531 void SetValueAsLong( int row, int col, long value ) {
2532 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2533 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2534 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
2535 }
2536 wxPyEndBlockThreads(blocked);
2537 }
2538
2539 void SetValueAsDouble( int row, int col, double value ) {
2540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2541 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2542 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
2543 }
2544 wxPyEndBlockThreads(blocked);
2545 }
2546
2547 void SetValueAsBool( int row, int col, bool value ) {
2548 SetValueAsLong( row, col, (long)value );
2549 }
2550
2551
2552 PYPRIVATE;
2553 };
2554
2555 static void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
2556
2557 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
2558
2559 if (source == Py_None) {
2560 **obj = wxGridCellCoords(-1,-1);
2561 return true;
2562 }
2563
2564 // If source is an object instance then it may already be the right type
2565 if (wxPySwigInstance_Check(source)) {
2566 wxGridCellCoords* ptr;
2567 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2568 goto error;
2569 *obj = ptr;
2570 return true;
2571 }
2572 // otherwise a 2-tuple of integers is expected
2573 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2574 PyObject* o1 = PySequence_GetItem(source, 0);
2575 PyObject* o2 = PySequence_GetItem(source, 1);
2576 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2577 Py_DECREF(o1);
2578 Py_DECREF(o2);
2579 goto error;
2580 }
2581 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
2582 Py_DECREF(o1);
2583 Py_DECREF(o2);
2584 return true;
2585 }
2586
2587 error:
2588 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
2589 return false;
2590 }
2591
2592
2593 bool wxGridCellCoords_typecheck(PyObject* source) {
2594 void* ptr;
2595
2596 if (wxPySwigInstance_Check(source) &&
2597 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2598 return true;
2599
2600 PyErr_Clear();
2601 if (PySequence_Check(source) && PySequence_Length(source) == 2)
2602 return true;
2603
2604 return false;
2605 }
2606
2607
2608 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
2609 {
2610 PyObject* list = PyList_New(0);
2611 size_t idx;
2612 for (idx = 0; idx < source.GetCount(); idx += 1) {
2613 wxGridCellCoords& coord = source.Item(idx);
2614 PyObject* tup = PyTuple_New(2);
2615 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
2616 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
2617 PyList_Append(list, tup);
2618 Py_DECREF(tup);
2619 }
2620 return list;
2621 }
2622
2623 static PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
2624 PyObject* tup = PyTuple_New(2);
2625 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
2626 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
2627 return tup;
2628 }
2629
2630 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
2631
2632
2633 static wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
2634 wxGridCellCoords rv;
2635 self->XYToCell(x, y, rv);
2636 return rv;
2637 }
2638 #ifdef __cplusplus
2639 extern "C" {
2640 #endif
2641 static int _wrap_GridNoCellCoords_set(PyObject *) {
2642 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2643 return 1;
2644 }
2645
2646
2647 static PyObject *_wrap_GridNoCellCoords_get(void) {
2648 PyObject *pyobj;
2649
2650 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2651 return pyobj;
2652 }
2653
2654
2655 static int _wrap_GridNoCellRect_set(PyObject *) {
2656 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2657 return 1;
2658 }
2659
2660
2661 static PyObject *_wrap_GridNoCellRect_get(void) {
2662 PyObject *pyobj;
2663
2664 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2665 return pyobj;
2666 }
2667
2668
2669 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2670 PyObject *resultobj;
2671 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2672 PyObject *arg2 = (PyObject *) 0 ;
2673 PyObject * obj0 = 0 ;
2674 PyObject * obj1 = 0 ;
2675 char *kwnames[] = {
2676 (char *) "self",(char *) "_self", NULL
2677 };
2678
2679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2681 if (SWIG_arg_fail(1)) SWIG_fail;
2682 arg2 = obj1;
2683 {
2684 PyThreadState* __tstate = wxPyBeginAllowThreads();
2685 wxGridCellRenderer__setOORInfo(arg1,arg2);
2686
2687 wxPyEndAllowThreads(__tstate);
2688 if (PyErr_Occurred()) SWIG_fail;
2689 }
2690 Py_INCREF(Py_None); resultobj = Py_None;
2691 return resultobj;
2692 fail:
2693 return NULL;
2694 }
2695
2696
2697 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2698 PyObject *resultobj;
2699 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2700 wxString *arg2 = 0 ;
2701 bool temp2 = false ;
2702 PyObject * obj0 = 0 ;
2703 PyObject * obj1 = 0 ;
2704 char *kwnames[] = {
2705 (char *) "self",(char *) "params", NULL
2706 };
2707
2708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2710 if (SWIG_arg_fail(1)) SWIG_fail;
2711 {
2712 arg2 = wxString_in_helper(obj1);
2713 if (arg2 == NULL) SWIG_fail;
2714 temp2 = true;
2715 }
2716 {
2717 PyThreadState* __tstate = wxPyBeginAllowThreads();
2718 (arg1)->SetParameters((wxString const &)*arg2);
2719
2720 wxPyEndAllowThreads(__tstate);
2721 if (PyErr_Occurred()) SWIG_fail;
2722 }
2723 Py_INCREF(Py_None); resultobj = Py_None;
2724 {
2725 if (temp2)
2726 delete arg2;
2727 }
2728 return resultobj;
2729 fail:
2730 {
2731 if (temp2)
2732 delete arg2;
2733 }
2734 return NULL;
2735 }
2736
2737
2738 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2739 PyObject *resultobj;
2740 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2741 PyObject * obj0 = 0 ;
2742 char *kwnames[] = {
2743 (char *) "self", NULL
2744 };
2745
2746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2748 if (SWIG_arg_fail(1)) SWIG_fail;
2749 {
2750 PyThreadState* __tstate = wxPyBeginAllowThreads();
2751 (arg1)->IncRef();
2752
2753 wxPyEndAllowThreads(__tstate);
2754 if (PyErr_Occurred()) SWIG_fail;
2755 }
2756 Py_INCREF(Py_None); resultobj = Py_None;
2757 return resultobj;
2758 fail:
2759 return NULL;
2760 }
2761
2762
2763 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2764 PyObject *resultobj;
2765 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2766 PyObject * obj0 = 0 ;
2767 char *kwnames[] = {
2768 (char *) "self", NULL
2769 };
2770
2771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2773 if (SWIG_arg_fail(1)) SWIG_fail;
2774 {
2775 PyThreadState* __tstate = wxPyBeginAllowThreads();
2776 (arg1)->DecRef();
2777
2778 wxPyEndAllowThreads(__tstate);
2779 if (PyErr_Occurred()) SWIG_fail;
2780 }
2781 Py_INCREF(Py_None); resultobj = Py_None;
2782 return resultobj;
2783 fail:
2784 return NULL;
2785 }
2786
2787
2788 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
2789 PyObject *resultobj;
2790 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2791 wxGrid *arg2 = 0 ;
2792 wxGridCellAttr *arg3 = 0 ;
2793 wxDC *arg4 = 0 ;
2794 wxRect *arg5 = 0 ;
2795 int arg6 ;
2796 int arg7 ;
2797 bool arg8 ;
2798 wxRect temp5 ;
2799 PyObject * obj0 = 0 ;
2800 PyObject * obj1 = 0 ;
2801 PyObject * obj2 = 0 ;
2802 PyObject * obj3 = 0 ;
2803 PyObject * obj4 = 0 ;
2804 PyObject * obj5 = 0 ;
2805 PyObject * obj6 = 0 ;
2806 PyObject * obj7 = 0 ;
2807 char *kwnames[] = {
2808 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
2809 };
2810
2811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2813 if (SWIG_arg_fail(1)) SWIG_fail;
2814 {
2815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2816 if (SWIG_arg_fail(2)) SWIG_fail;
2817 if (arg2 == NULL) {
2818 SWIG_null_ref("wxGrid");
2819 }
2820 if (SWIG_arg_fail(2)) SWIG_fail;
2821 }
2822 {
2823 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2824 if (SWIG_arg_fail(3)) SWIG_fail;
2825 if (arg3 == NULL) {
2826 SWIG_null_ref("wxGridCellAttr");
2827 }
2828 if (SWIG_arg_fail(3)) SWIG_fail;
2829 }
2830 {
2831 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(4)) SWIG_fail;
2833 if (arg4 == NULL) {
2834 SWIG_null_ref("wxDC");
2835 }
2836 if (SWIG_arg_fail(4)) SWIG_fail;
2837 }
2838 {
2839 arg5 = &temp5;
2840 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
2841 }
2842 {
2843 arg6 = (int)(SWIG_As_int(obj5));
2844 if (SWIG_arg_fail(6)) SWIG_fail;
2845 }
2846 {
2847 arg7 = (int)(SWIG_As_int(obj6));
2848 if (SWIG_arg_fail(7)) SWIG_fail;
2849 }
2850 {
2851 arg8 = (bool)(SWIG_As_bool(obj7));
2852 if (SWIG_arg_fail(8)) SWIG_fail;
2853 }
2854 {
2855 PyThreadState* __tstate = wxPyBeginAllowThreads();
2856 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
2857
2858 wxPyEndAllowThreads(__tstate);
2859 if (PyErr_Occurred()) SWIG_fail;
2860 }
2861 Py_INCREF(Py_None); resultobj = Py_None;
2862 return resultobj;
2863 fail:
2864 return NULL;
2865 }
2866
2867
2868 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
2869 PyObject *resultobj;
2870 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2871 wxGrid *arg2 = 0 ;
2872 wxGridCellAttr *arg3 = 0 ;
2873 wxDC *arg4 = 0 ;
2874 int arg5 ;
2875 int arg6 ;
2876 wxSize result;
2877 PyObject * obj0 = 0 ;
2878 PyObject * obj1 = 0 ;
2879 PyObject * obj2 = 0 ;
2880 PyObject * obj3 = 0 ;
2881 PyObject * obj4 = 0 ;
2882 PyObject * obj5 = 0 ;
2883 char *kwnames[] = {
2884 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
2885 };
2886
2887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2889 if (SWIG_arg_fail(1)) SWIG_fail;
2890 {
2891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(2)) SWIG_fail;
2893 if (arg2 == NULL) {
2894 SWIG_null_ref("wxGrid");
2895 }
2896 if (SWIG_arg_fail(2)) SWIG_fail;
2897 }
2898 {
2899 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
2900 if (SWIG_arg_fail(3)) SWIG_fail;
2901 if (arg3 == NULL) {
2902 SWIG_null_ref("wxGridCellAttr");
2903 }
2904 if (SWIG_arg_fail(3)) SWIG_fail;
2905 }
2906 {
2907 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
2908 if (SWIG_arg_fail(4)) SWIG_fail;
2909 if (arg4 == NULL) {
2910 SWIG_null_ref("wxDC");
2911 }
2912 if (SWIG_arg_fail(4)) SWIG_fail;
2913 }
2914 {
2915 arg5 = (int)(SWIG_As_int(obj4));
2916 if (SWIG_arg_fail(5)) SWIG_fail;
2917 }
2918 {
2919 arg6 = (int)(SWIG_As_int(obj5));
2920 if (SWIG_arg_fail(6)) SWIG_fail;
2921 }
2922 {
2923 PyThreadState* __tstate = wxPyBeginAllowThreads();
2924 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
2925
2926 wxPyEndAllowThreads(__tstate);
2927 if (PyErr_Occurred()) SWIG_fail;
2928 }
2929 {
2930 wxSize * resultptr;
2931 resultptr = new wxSize((wxSize &)(result));
2932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2933 }
2934 return resultobj;
2935 fail:
2936 return NULL;
2937 }
2938
2939
2940 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
2941 PyObject *resultobj;
2942 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2943 wxGridCellRenderer *result;
2944 PyObject * obj0 = 0 ;
2945 char *kwnames[] = {
2946 (char *) "self", NULL
2947 };
2948
2949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
2950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2951 if (SWIG_arg_fail(1)) SWIG_fail;
2952 {
2953 PyThreadState* __tstate = wxPyBeginAllowThreads();
2954 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
2955
2956 wxPyEndAllowThreads(__tstate);
2957 if (PyErr_Occurred()) SWIG_fail;
2958 }
2959 {
2960 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
2961 }
2962 return resultobj;
2963 fail:
2964 return NULL;
2965 }
2966
2967
2968 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
2969 PyObject *obj;
2970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2971 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
2972 Py_INCREF(obj);
2973 return Py_BuildValue((char *)"");
2974 }
2975 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
2976 PyObject *resultobj;
2977 wxPyGridCellRenderer *result;
2978 char *kwnames[] = {
2979 NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
2983 {
2984 PyThreadState* __tstate = wxPyBeginAllowThreads();
2985 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
2986
2987 wxPyEndAllowThreads(__tstate);
2988 if (PyErr_Occurred()) SWIG_fail;
2989 }
2990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
2991 return resultobj;
2992 fail:
2993 return NULL;
2994 }
2995
2996
2997 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2998 PyObject *resultobj;
2999 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3000 PyObject *arg2 = (PyObject *) 0 ;
3001 PyObject *arg3 = (PyObject *) 0 ;
3002 PyObject * obj0 = 0 ;
3003 PyObject * obj1 = 0 ;
3004 PyObject * obj2 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self",(char *) "self",(char *) "_class", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 arg2 = obj1;
3013 arg3 = obj2;
3014 {
3015 PyThreadState* __tstate = wxPyBeginAllowThreads();
3016 (arg1)->_setCallbackInfo(arg2,arg3);
3017
3018 wxPyEndAllowThreads(__tstate);
3019 if (PyErr_Occurred()) SWIG_fail;
3020 }
3021 Py_INCREF(Py_None); resultobj = Py_None;
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject *_wrap_PyGridCellRenderer_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3029 PyObject *resultobj;
3030 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3031 wxString *arg2 = 0 ;
3032 bool temp2 = false ;
3033 PyObject * obj0 = 0 ;
3034 PyObject * obj1 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "self",(char *) "params", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 {
3043 arg2 = wxString_in_helper(obj1);
3044 if (arg2 == NULL) SWIG_fail;
3045 temp2 = true;
3046 }
3047 {
3048 PyThreadState* __tstate = wxPyBeginAllowThreads();
3049 (arg1)->base_SetParameters((wxString const &)*arg2);
3050
3051 wxPyEndAllowThreads(__tstate);
3052 if (PyErr_Occurred()) SWIG_fail;
3053 }
3054 Py_INCREF(Py_None); resultobj = Py_None;
3055 {
3056 if (temp2)
3057 delete arg2;
3058 }
3059 return resultobj;
3060 fail:
3061 {
3062 if (temp2)
3063 delete arg2;
3064 }
3065 return NULL;
3066 }
3067
3068
3069 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3070 PyObject *obj;
3071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3072 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3073 Py_INCREF(obj);
3074 return Py_BuildValue((char *)"");
3075 }
3076 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3077 PyObject *resultobj;
3078 wxGridCellStringRenderer *result;
3079 char *kwnames[] = {
3080 NULL
3081 };
3082
3083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3084 {
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3099 PyObject *obj;
3100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3101 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3102 Py_INCREF(obj);
3103 return Py_BuildValue((char *)"");
3104 }
3105 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3106 PyObject *resultobj;
3107 wxGridCellNumberRenderer *result;
3108 char *kwnames[] = {
3109 NULL
3110 };
3111
3112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3113 {
3114 PyThreadState* __tstate = wxPyBeginAllowThreads();
3115 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3116
3117 wxPyEndAllowThreads(__tstate);
3118 if (PyErr_Occurred()) SWIG_fail;
3119 }
3120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3121 return resultobj;
3122 fail:
3123 return NULL;
3124 }
3125
3126
3127 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3128 PyObject *obj;
3129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3130 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3131 Py_INCREF(obj);
3132 return Py_BuildValue((char *)"");
3133 }
3134 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 int arg1 = (int) -1 ;
3137 int arg2 = (int) -1 ;
3138 wxGridCellFloatRenderer *result;
3139 PyObject * obj0 = 0 ;
3140 PyObject * obj1 = 0 ;
3141 char *kwnames[] = {
3142 (char *) "width",(char *) "precision", NULL
3143 };
3144
3145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3146 if (obj0) {
3147 {
3148 arg1 = (int)(SWIG_As_int(obj0));
3149 if (SWIG_arg_fail(1)) SWIG_fail;
3150 }
3151 }
3152 if (obj1) {
3153 {
3154 arg2 = (int)(SWIG_As_int(obj1));
3155 if (SWIG_arg_fail(2)) SWIG_fail;
3156 }
3157 }
3158 {
3159 PyThreadState* __tstate = wxPyBeginAllowThreads();
3160 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3161
3162 wxPyEndAllowThreads(__tstate);
3163 if (PyErr_Occurred()) SWIG_fail;
3164 }
3165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3166 return resultobj;
3167 fail:
3168 return NULL;
3169 }
3170
3171
3172 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3173 PyObject *resultobj;
3174 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3175 int result;
3176 PyObject * obj0 = 0 ;
3177 char *kwnames[] = {
3178 (char *) "self", NULL
3179 };
3180
3181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3183 if (SWIG_arg_fail(1)) SWIG_fail;
3184 {
3185 PyThreadState* __tstate = wxPyBeginAllowThreads();
3186 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3187
3188 wxPyEndAllowThreads(__tstate);
3189 if (PyErr_Occurred()) SWIG_fail;
3190 }
3191 {
3192 resultobj = SWIG_From_int((int)(result));
3193 }
3194 return resultobj;
3195 fail:
3196 return NULL;
3197 }
3198
3199
3200 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3201 PyObject *resultobj;
3202 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3203 int arg2 ;
3204 PyObject * obj0 = 0 ;
3205 PyObject * obj1 = 0 ;
3206 char *kwnames[] = {
3207 (char *) "self",(char *) "width", NULL
3208 };
3209
3210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3212 if (SWIG_arg_fail(1)) SWIG_fail;
3213 {
3214 arg2 = (int)(SWIG_As_int(obj1));
3215 if (SWIG_arg_fail(2)) SWIG_fail;
3216 }
3217 {
3218 PyThreadState* __tstate = wxPyBeginAllowThreads();
3219 (arg1)->SetWidth(arg2);
3220
3221 wxPyEndAllowThreads(__tstate);
3222 if (PyErr_Occurred()) SWIG_fail;
3223 }
3224 Py_INCREF(Py_None); resultobj = Py_None;
3225 return resultobj;
3226 fail:
3227 return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3232 PyObject *resultobj;
3233 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3234 int result;
3235 PyObject * obj0 = 0 ;
3236 char *kwnames[] = {
3237 (char *) "self", NULL
3238 };
3239
3240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3242 if (SWIG_arg_fail(1)) SWIG_fail;
3243 {
3244 PyThreadState* __tstate = wxPyBeginAllowThreads();
3245 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3246
3247 wxPyEndAllowThreads(__tstate);
3248 if (PyErr_Occurred()) SWIG_fail;
3249 }
3250 {
3251 resultobj = SWIG_From_int((int)(result));
3252 }
3253 return resultobj;
3254 fail:
3255 return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3260 PyObject *resultobj;
3261 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3262 int arg2 ;
3263 PyObject * obj0 = 0 ;
3264 PyObject * obj1 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self",(char *) "precision", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 arg2 = (int)(SWIG_As_int(obj1));
3274 if (SWIG_arg_fail(2)) SWIG_fail;
3275 }
3276 {
3277 PyThreadState* __tstate = wxPyBeginAllowThreads();
3278 (arg1)->SetPrecision(arg2);
3279
3280 wxPyEndAllowThreads(__tstate);
3281 if (PyErr_Occurred()) SWIG_fail;
3282 }
3283 Py_INCREF(Py_None); resultobj = Py_None;
3284 return resultobj;
3285 fail:
3286 return NULL;
3287 }
3288
3289
3290 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3291 PyObject *obj;
3292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3293 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3294 Py_INCREF(obj);
3295 return Py_BuildValue((char *)"");
3296 }
3297 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3298 PyObject *resultobj;
3299 wxGridCellBoolRenderer *result;
3300 char *kwnames[] = {
3301 NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3305 {
3306 PyThreadState* __tstate = wxPyBeginAllowThreads();
3307 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3308
3309 wxPyEndAllowThreads(__tstate);
3310 if (PyErr_Occurred()) SWIG_fail;
3311 }
3312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3313 return resultobj;
3314 fail:
3315 return NULL;
3316 }
3317
3318
3319 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3320 PyObject *obj;
3321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3322 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3323 Py_INCREF(obj);
3324 return Py_BuildValue((char *)"");
3325 }
3326 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
3329 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
3330 wxGridCellDateTimeRenderer *result;
3331 PyObject * obj0 = 0 ;
3332 PyObject * obj1 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "outformat",(char *) "informat", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3338 if (obj0) {
3339 {
3340 wxString* sptr = wxString_in_helper(obj0);
3341 if (sptr == NULL) SWIG_fail;
3342 arg1 = *sptr;
3343 delete sptr;
3344 }
3345 }
3346 if (obj1) {
3347 {
3348 wxString* sptr = wxString_in_helper(obj1);
3349 if (sptr == NULL) SWIG_fail;
3350 arg2 = *sptr;
3351 delete sptr;
3352 }
3353 }
3354 {
3355 PyThreadState* __tstate = wxPyBeginAllowThreads();
3356 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3357
3358 wxPyEndAllowThreads(__tstate);
3359 if (PyErr_Occurred()) SWIG_fail;
3360 }
3361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3369 PyObject *obj;
3370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3371 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3372 Py_INCREF(obj);
3373 return Py_BuildValue((char *)"");
3374 }
3375 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3376 PyObject *resultobj;
3377 wxString const &arg1_defvalue = wxPyEmptyString ;
3378 wxString *arg1 = (wxString *) &arg1_defvalue ;
3379 wxGridCellEnumRenderer *result;
3380 bool temp1 = false ;
3381 PyObject * obj0 = 0 ;
3382 char *kwnames[] = {
3383 (char *) "choices", NULL
3384 };
3385
3386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3387 if (obj0) {
3388 {
3389 arg1 = wxString_in_helper(obj0);
3390 if (arg1 == NULL) SWIG_fail;
3391 temp1 = true;
3392 }
3393 }
3394 {
3395 PyThreadState* __tstate = wxPyBeginAllowThreads();
3396 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3397
3398 wxPyEndAllowThreads(__tstate);
3399 if (PyErr_Occurred()) SWIG_fail;
3400 }
3401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3402 {
3403 if (temp1)
3404 delete arg1;
3405 }
3406 return resultobj;
3407 fail:
3408 {
3409 if (temp1)
3410 delete arg1;
3411 }
3412 return NULL;
3413 }
3414
3415
3416 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3417 PyObject *obj;
3418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3419 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3420 Py_INCREF(obj);
3421 return Py_BuildValue((char *)"");
3422 }
3423 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3424 PyObject *resultobj;
3425 wxGridCellAutoWrapStringRenderer *result;
3426 char *kwnames[] = {
3427 NULL
3428 };
3429
3430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3439 return resultobj;
3440 fail:
3441 return NULL;
3442 }
3443
3444
3445 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3446 PyObject *obj;
3447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3448 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3449 Py_INCREF(obj);
3450 return Py_BuildValue((char *)"");
3451 }
3452 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3453 PyObject *resultobj;
3454 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3455 PyObject *arg2 = (PyObject *) 0 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "_self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 arg2 = obj1;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 wxGridCellEditor__setOORInfo(arg1,arg2);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3483 bool result;
3484 PyObject * obj0 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 PyThreadState* __tstate = wxPyBeginAllowThreads();
3494 result = (bool)(arg1)->IsCreated();
3495
3496 wxPyEndAllowThreads(__tstate);
3497 if (PyErr_Occurred()) SWIG_fail;
3498 }
3499 {
3500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3501 }
3502 return resultobj;
3503 fail:
3504 return NULL;
3505 }
3506
3507
3508 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3509 PyObject *resultobj;
3510 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3511 wxControl *result;
3512 PyObject * obj0 = 0 ;
3513 char *kwnames[] = {
3514 (char *) "self", NULL
3515 };
3516
3517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3519 if (SWIG_arg_fail(1)) SWIG_fail;
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (wxControl *)(arg1)->GetControl();
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = wxPyMake_wxObject(result, 0);
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3539 wxControl *arg2 = (wxControl *) 0 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "control", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(2)) SWIG_fail;
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 (arg1)->SetControl(arg2);
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 Py_INCREF(Py_None); resultobj = Py_None;
3559 return resultobj;
3560 fail:
3561 return NULL;
3562 }
3563
3564
3565 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3566 PyObject *resultobj;
3567 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3568 wxGridCellAttr *result;
3569 PyObject * obj0 = 0 ;
3570 char *kwnames[] = {
3571 (char *) "self", NULL
3572 };
3573
3574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3576 if (SWIG_arg_fail(1)) SWIG_fail;
3577 {
3578 PyThreadState* __tstate = wxPyBeginAllowThreads();
3579 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3580
3581 wxPyEndAllowThreads(__tstate);
3582 if (PyErr_Occurred()) SWIG_fail;
3583 }
3584 {
3585 resultobj = wxPyMake_wxGridCellAttr(result, 0);
3586 }
3587 return resultobj;
3588 fail:
3589 return NULL;
3590 }
3591
3592
3593 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3594 PyObject *resultobj;
3595 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3596 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3597 PyObject * obj0 = 0 ;
3598 PyObject * obj1 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "self",(char *) "attr", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(1)) SWIG_fail;
3606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(2)) SWIG_fail;
3608 {
3609 PyThreadState* __tstate = wxPyBeginAllowThreads();
3610 (arg1)->SetCellAttr(arg2);
3611
3612 wxPyEndAllowThreads(__tstate);
3613 if (PyErr_Occurred()) SWIG_fail;
3614 }
3615 Py_INCREF(Py_None); resultobj = Py_None;
3616 return resultobj;
3617 fail:
3618 return NULL;
3619 }
3620
3621
3622 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3623 PyObject *resultobj;
3624 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3625 wxString *arg2 = 0 ;
3626 bool temp2 = false ;
3627 PyObject * obj0 = 0 ;
3628 PyObject * obj1 = 0 ;
3629 char *kwnames[] = {
3630 (char *) "self",(char *) "params", NULL
3631 };
3632
3633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3635 if (SWIG_arg_fail(1)) SWIG_fail;
3636 {
3637 arg2 = wxString_in_helper(obj1);
3638 if (arg2 == NULL) SWIG_fail;
3639 temp2 = true;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 (arg1)->SetParameters((wxString const &)*arg2);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 Py_INCREF(Py_None); resultobj = Py_None;
3649 {
3650 if (temp2)
3651 delete arg2;
3652 }
3653 return resultobj;
3654 fail:
3655 {
3656 if (temp2)
3657 delete arg2;
3658 }
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3666 PyObject * obj0 = 0 ;
3667 char *kwnames[] = {
3668 (char *) "self", NULL
3669 };
3670
3671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 (arg1)->IncRef();
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3691 PyObject * obj0 = 0 ;
3692 char *kwnames[] = {
3693 (char *) "self", NULL
3694 };
3695
3696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3698 if (SWIG_arg_fail(1)) SWIG_fail;
3699 {
3700 PyThreadState* __tstate = wxPyBeginAllowThreads();
3701 (arg1)->DecRef();
3702
3703 wxPyEndAllowThreads(__tstate);
3704 if (PyErr_Occurred()) SWIG_fail;
3705 }
3706 Py_INCREF(Py_None); resultobj = Py_None;
3707 return resultobj;
3708 fail:
3709 return NULL;
3710 }
3711
3712
3713 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3714 PyObject *resultobj;
3715 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3716 wxWindow *arg2 = (wxWindow *) 0 ;
3717 int arg3 ;
3718 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3719 PyObject * obj0 = 0 ;
3720 PyObject * obj1 = 0 ;
3721 PyObject * obj2 = 0 ;
3722 PyObject * obj3 = 0 ;
3723 char *kwnames[] = {
3724 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3725 };
3726
3727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3729 if (SWIG_arg_fail(1)) SWIG_fail;
3730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3731 if (SWIG_arg_fail(2)) SWIG_fail;
3732 {
3733 arg3 = (int)(SWIG_As_int(obj2));
3734 if (SWIG_arg_fail(3)) SWIG_fail;
3735 }
3736 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(4)) SWIG_fail;
3738 {
3739 PyThreadState* __tstate = wxPyBeginAllowThreads();
3740 (arg1)->Create(arg2,arg3,arg4);
3741
3742 wxPyEndAllowThreads(__tstate);
3743 if (PyErr_Occurred()) SWIG_fail;
3744 }
3745 Py_INCREF(Py_None); resultobj = Py_None;
3746 return resultobj;
3747 fail:
3748 return NULL;
3749 }
3750
3751
3752 static PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3753 PyObject *resultobj;
3754 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3755 int arg2 ;
3756 int arg3 ;
3757 wxGrid *arg4 = (wxGrid *) 0 ;
3758 PyObject * obj0 = 0 ;
3759 PyObject * obj1 = 0 ;
3760 PyObject * obj2 = 0 ;
3761 PyObject * obj3 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 arg3 = (int)(SWIG_As_int(obj2));
3775 if (SWIG_arg_fail(3)) SWIG_fail;
3776 }
3777 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3778 if (SWIG_arg_fail(4)) SWIG_fail;
3779 {
3780 PyThreadState* __tstate = wxPyBeginAllowThreads();
3781 (arg1)->BeginEdit(arg2,arg3,arg4);
3782
3783 wxPyEndAllowThreads(__tstate);
3784 if (PyErr_Occurred()) SWIG_fail;
3785 }
3786 Py_INCREF(Py_None); resultobj = Py_None;
3787 return resultobj;
3788 fail:
3789 return NULL;
3790 }
3791
3792
3793 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3794 PyObject *resultobj;
3795 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3796 int arg2 ;
3797 int arg3 ;
3798 wxGrid *arg4 = (wxGrid *) 0 ;
3799 bool result;
3800 PyObject * obj0 = 0 ;
3801 PyObject * obj1 = 0 ;
3802 PyObject * obj2 = 0 ;
3803 PyObject * obj3 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3810 if (SWIG_arg_fail(1)) SWIG_fail;
3811 {
3812 arg2 = (int)(SWIG_As_int(obj1));
3813 if (SWIG_arg_fail(2)) SWIG_fail;
3814 }
3815 {
3816 arg3 = (int)(SWIG_As_int(obj2));
3817 if (SWIG_arg_fail(3)) SWIG_fail;
3818 }
3819 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(4)) SWIG_fail;
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3840 PyObject * obj0 = 0 ;
3841 char *kwnames[] = {
3842 (char *) "self", NULL
3843 };
3844
3845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
3846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3847 if (SWIG_arg_fail(1)) SWIG_fail;
3848 {
3849 PyThreadState* __tstate = wxPyBeginAllowThreads();
3850 (arg1)->Reset();
3851
3852 wxPyEndAllowThreads(__tstate);
3853 if (PyErr_Occurred()) SWIG_fail;
3854 }
3855 Py_INCREF(Py_None); resultobj = Py_None;
3856 return resultobj;
3857 fail:
3858 return NULL;
3859 }
3860
3861
3862 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3863 PyObject *resultobj;
3864 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3865 wxGridCellEditor *result;
3866 PyObject * obj0 = 0 ;
3867 char *kwnames[] = {
3868 (char *) "self", NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
3872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3873 if (SWIG_arg_fail(1)) SWIG_fail;
3874 {
3875 PyThreadState* __tstate = wxPyBeginAllowThreads();
3876 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
3877
3878 wxPyEndAllowThreads(__tstate);
3879 if (PyErr_Occurred()) SWIG_fail;
3880 }
3881 {
3882 resultobj = wxPyMake_wxGridCellEditor(result, 0);
3883 }
3884 return resultobj;
3885 fail:
3886 return NULL;
3887 }
3888
3889
3890 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
3891 PyObject *resultobj;
3892 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3893 wxRect *arg2 = 0 ;
3894 wxRect temp2 ;
3895 PyObject * obj0 = 0 ;
3896 PyObject * obj1 = 0 ;
3897 char *kwnames[] = {
3898 (char *) "self",(char *) "rect", NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
3902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3903 if (SWIG_arg_fail(1)) SWIG_fail;
3904 {
3905 arg2 = &temp2;
3906 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3907 }
3908 {
3909 PyThreadState* __tstate = wxPyBeginAllowThreads();
3910 (arg1)->SetSize((wxRect const &)*arg2);
3911
3912 wxPyEndAllowThreads(__tstate);
3913 if (PyErr_Occurred()) SWIG_fail;
3914 }
3915 Py_INCREF(Py_None); resultobj = Py_None;
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3925 bool arg2 ;
3926 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
3927 PyObject * obj0 = 0 ;
3928 PyObject * obj1 = 0 ;
3929 PyObject * obj2 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "self",(char *) "show",(char *) "attr", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
3935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(1)) SWIG_fail;
3937 {
3938 arg2 = (bool)(SWIG_As_bool(obj1));
3939 if (SWIG_arg_fail(2)) SWIG_fail;
3940 }
3941 if (obj2) {
3942 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3943 if (SWIG_arg_fail(3)) SWIG_fail;
3944 }
3945 {
3946 PyThreadState* __tstate = wxPyBeginAllowThreads();
3947 (arg1)->Show(arg2,arg3);
3948
3949 wxPyEndAllowThreads(__tstate);
3950 if (PyErr_Occurred()) SWIG_fail;
3951 }
3952 Py_INCREF(Py_None); resultobj = Py_None;
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3962 wxRect *arg2 = 0 ;
3963 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
3964 wxRect temp2 ;
3965 PyObject * obj0 = 0 ;
3966 PyObject * obj1 = 0 ;
3967 PyObject * obj2 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 arg2 = &temp2;
3977 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3978 }
3979 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3980 if (SWIG_arg_fail(3)) SWIG_fail;
3981 {
3982 PyThreadState* __tstate = wxPyBeginAllowThreads();
3983 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
3984
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3998 wxKeyEvent *arg2 = 0 ;
3999 bool result;
4000 PyObject * obj0 = 0 ;
4001 PyObject * obj1 = 0 ;
4002 char *kwnames[] = {
4003 (char *) "self",(char *) "event", NULL
4004 };
4005
4006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4008 if (SWIG_arg_fail(1)) SWIG_fail;
4009 {
4010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4011 if (SWIG_arg_fail(2)) SWIG_fail;
4012 if (arg2 == NULL) {
4013 SWIG_null_ref("wxKeyEvent");
4014 }
4015 if (SWIG_arg_fail(2)) SWIG_fail;
4016 }
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4020
4021 wxPyEndAllowThreads(__tstate);
4022 if (PyErr_Occurred()) SWIG_fail;
4023 }
4024 {
4025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4026 }
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4036 wxKeyEvent *arg2 = 0 ;
4037 PyObject * obj0 = 0 ;
4038 PyObject * obj1 = 0 ;
4039 char *kwnames[] = {
4040 (char *) "self",(char *) "event", NULL
4041 };
4042
4043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4045 if (SWIG_arg_fail(1)) SWIG_fail;
4046 {
4047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(2)) SWIG_fail;
4049 if (arg2 == NULL) {
4050 SWIG_null_ref("wxKeyEvent");
4051 }
4052 if (SWIG_arg_fail(2)) SWIG_fail;
4053 }
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 (arg1)->StartingKey(*arg2);
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 Py_INCREF(Py_None); resultobj = Py_None;
4062 return resultobj;
4063 fail:
4064 return NULL;
4065 }
4066
4067
4068 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj;
4070 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4071 PyObject * obj0 = 0 ;
4072 char *kwnames[] = {
4073 (char *) "self", NULL
4074 };
4075
4076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4078 if (SWIG_arg_fail(1)) SWIG_fail;
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 (arg1)->StartingClick();
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 Py_INCREF(Py_None); resultobj = Py_None;
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4096 wxKeyEvent *arg2 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 PyObject * obj1 = 0 ;
4099 char *kwnames[] = {
4100 (char *) "self",(char *) "event", NULL
4101 };
4102
4103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4105 if (SWIG_arg_fail(1)) SWIG_fail;
4106 {
4107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(2)) SWIG_fail;
4109 if (arg2 == NULL) {
4110 SWIG_null_ref("wxKeyEvent");
4111 }
4112 if (SWIG_arg_fail(2)) SWIG_fail;
4113 }
4114 {
4115 PyThreadState* __tstate = wxPyBeginAllowThreads();
4116 (arg1)->HandleReturn(*arg2);
4117
4118 wxPyEndAllowThreads(__tstate);
4119 if (PyErr_Occurred()) SWIG_fail;
4120 }
4121 Py_INCREF(Py_None); resultobj = Py_None;
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj;
4130 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4131 PyObject * obj0 = 0 ;
4132 char *kwnames[] = {
4133 (char *) "self", NULL
4134 };
4135
4136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 (arg1)->Destroy();
4142
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 Py_INCREF(Py_None); resultobj = Py_None;
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4154 PyObject *obj;
4155 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4156 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4157 Py_INCREF(obj);
4158 return Py_BuildValue((char *)"");
4159 }
4160 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 wxPyGridCellEditor *result;
4163 char *kwnames[] = {
4164 NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4176 return resultobj;
4177 fail:
4178 return NULL;
4179 }
4180
4181
4182 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4183 PyObject *resultobj;
4184 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4185 PyObject *arg2 = (PyObject *) 0 ;
4186 PyObject *arg3 = (PyObject *) 0 ;
4187 PyObject * obj0 = 0 ;
4188 PyObject * obj1 = 0 ;
4189 PyObject * obj2 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "self",(char *) "self",(char *) "_class", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 arg2 = obj1;
4198 arg3 = obj2;
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 (arg1)->_setCallbackInfo(arg2,arg3);
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 Py_INCREF(Py_None); resultobj = Py_None;
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_PyGridCellEditor_base_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4216 wxRect *arg2 = 0 ;
4217 wxRect temp2 ;
4218 PyObject * obj0 = 0 ;
4219 PyObject * obj1 = 0 ;
4220 char *kwnames[] = {
4221 (char *) "self",(char *) "rect", NULL
4222 };
4223
4224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetSize",kwnames,&obj0,&obj1)) goto fail;
4225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4226 if (SWIG_arg_fail(1)) SWIG_fail;
4227 {
4228 arg2 = &temp2;
4229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4230 }
4231 {
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 (arg1)->base_SetSize((wxRect const &)*arg2);
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 Py_INCREF(Py_None); resultobj = Py_None;
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_PyGridCellEditor_base_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4248 bool arg2 ;
4249 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4250 PyObject * obj0 = 0 ;
4251 PyObject * obj1 = 0 ;
4252 PyObject * obj2 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self",(char *) "show",(char *) "attr", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_base_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 arg2 = (bool)(SWIG_As_bool(obj1));
4262 if (SWIG_arg_fail(2)) SWIG_fail;
4263 }
4264 if (obj2) {
4265 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4266 if (SWIG_arg_fail(3)) SWIG_fail;
4267 }
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 (arg1)->base_Show(arg2,arg3);
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 Py_INCREF(Py_None); resultobj = Py_None;
4276 return resultobj;
4277 fail:
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_PyGridCellEditor_base_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4285 wxRect *arg2 = 0 ;
4286 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4287 wxRect temp2 ;
4288 PyObject * obj0 = 0 ;
4289 PyObject * obj1 = 0 ;
4290 PyObject * obj2 = 0 ;
4291 char *kwnames[] = {
4292 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_base_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4297 if (SWIG_arg_fail(1)) SWIG_fail;
4298 {
4299 arg2 = &temp2;
4300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4301 }
4302 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4303 if (SWIG_arg_fail(3)) SWIG_fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 (arg1)->base_PaintBackground((wxRect const &)*arg2,arg3);
4307
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 Py_INCREF(Py_None); resultobj = Py_None;
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_PyGridCellEditor_base_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4321 wxKeyEvent *arg2 = 0 ;
4322 bool result;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self",(char *) "event", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 {
4333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4334 if (SWIG_arg_fail(2)) SWIG_fail;
4335 if (arg2 == NULL) {
4336 SWIG_null_ref("wxKeyEvent");
4337 }
4338 if (SWIG_arg_fail(2)) SWIG_fail;
4339 }
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 result = (bool)(arg1)->base_IsAcceptedKey(*arg2);
4343
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 {
4348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4349 }
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_PyGridCellEditor_base_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4359 wxKeyEvent *arg2 = 0 ;
4360 PyObject * obj0 = 0 ;
4361 PyObject * obj1 = 0 ;
4362 char *kwnames[] = {
4363 (char *) "self",(char *) "event", NULL
4364 };
4365
4366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4368 if (SWIG_arg_fail(1)) SWIG_fail;
4369 {
4370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(2)) SWIG_fail;
4372 if (arg2 == NULL) {
4373 SWIG_null_ref("wxKeyEvent");
4374 }
4375 if (SWIG_arg_fail(2)) SWIG_fail;
4376 }
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
4379 (arg1)->base_StartingKey(*arg2);
4380
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 Py_INCREF(Py_None); resultobj = Py_None;
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_PyGridCellEditor_base_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4394 PyObject * obj0 = 0 ;
4395 char *kwnames[] = {
4396 (char *) "self", NULL
4397 };
4398
4399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_StartingClick",kwnames,&obj0)) goto fail;
4400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4401 if (SWIG_arg_fail(1)) SWIG_fail;
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 (arg1)->base_StartingClick();
4405
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 Py_INCREF(Py_None); resultobj = Py_None;
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 static PyObject *_wrap_PyGridCellEditor_base_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4417 PyObject *resultobj;
4418 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4419 wxKeyEvent *arg2 = 0 ;
4420 PyObject * obj0 = 0 ;
4421 PyObject * obj1 = 0 ;
4422 char *kwnames[] = {
4423 (char *) "self",(char *) "event", NULL
4424 };
4425
4426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4428 if (SWIG_arg_fail(1)) SWIG_fail;
4429 {
4430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(2)) SWIG_fail;
4432 if (arg2 == NULL) {
4433 SWIG_null_ref("wxKeyEvent");
4434 }
4435 if (SWIG_arg_fail(2)) SWIG_fail;
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 (arg1)->base_HandleReturn(*arg2);
4440
4441 wxPyEndAllowThreads(__tstate);
4442 if (PyErr_Occurred()) SWIG_fail;
4443 }
4444 Py_INCREF(Py_None); resultobj = Py_None;
4445 return resultobj;
4446 fail:
4447 return NULL;
4448 }
4449
4450
4451 static PyObject *_wrap_PyGridCellEditor_base_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4452 PyObject *resultobj;
4453 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4454 PyObject * obj0 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "self", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_Destroy",kwnames,&obj0)) goto fail;
4460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(1)) SWIG_fail;
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 (arg1)->base_Destroy();
4465
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 Py_INCREF(Py_None); resultobj = Py_None;
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 static PyObject *_wrap_PyGridCellEditor_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4477 PyObject *resultobj;
4478 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4479 wxString *arg2 = 0 ;
4480 bool temp2 = false ;
4481 PyObject * obj0 = 0 ;
4482 PyObject * obj1 = 0 ;
4483 char *kwnames[] = {
4484 (char *) "self",(char *) "params", NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
4488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4489 if (SWIG_arg_fail(1)) SWIG_fail;
4490 {
4491 arg2 = wxString_in_helper(obj1);
4492 if (arg2 == NULL) SWIG_fail;
4493 temp2 = true;
4494 }
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 (arg1)->base_SetParameters((wxString const &)*arg2);
4498
4499 wxPyEndAllowThreads(__tstate);
4500 if (PyErr_Occurred()) SWIG_fail;
4501 }
4502 Py_INCREF(Py_None); resultobj = Py_None;
4503 {
4504 if (temp2)
4505 delete arg2;
4506 }
4507 return resultobj;
4508 fail:
4509 {
4510 if (temp2)
4511 delete arg2;
4512 }
4513 return NULL;
4514 }
4515
4516
4517 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4518 PyObject *obj;
4519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4520 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4521 Py_INCREF(obj);
4522 return Py_BuildValue((char *)"");
4523 }
4524 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj;
4526 wxGridCellTextEditor *result;
4527 char *kwnames[] = {
4528 NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4535
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj;
4548 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4549 wxString result;
4550 PyObject * obj0 = 0 ;
4551 char *kwnames[] = {
4552 (char *) "self", NULL
4553 };
4554
4555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4557 if (SWIG_arg_fail(1)) SWIG_fail;
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (arg1)->GetValue();
4561
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 {
4566 #if wxUSE_UNICODE
4567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4568 #else
4569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4570 #endif
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4579 PyObject *obj;
4580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4581 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4582 Py_INCREF(obj);
4583 return Py_BuildValue((char *)"");
4584 }
4585 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj;
4587 int arg1 = (int) -1 ;
4588 int arg2 = (int) -1 ;
4589 wxGridCellNumberEditor *result;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 char *kwnames[] = {
4593 (char *) "min",(char *) "max", NULL
4594 };
4595
4596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4597 if (obj0) {
4598 {
4599 arg1 = (int)(SWIG_As_int(obj0));
4600 if (SWIG_arg_fail(1)) SWIG_fail;
4601 }
4602 }
4603 if (obj1) {
4604 {
4605 arg2 = (int)(SWIG_As_int(obj1));
4606 if (SWIG_arg_fail(2)) SWIG_fail;
4607 }
4608 }
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj;
4625 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4626 wxString result;
4627 PyObject * obj0 = 0 ;
4628 char *kwnames[] = {
4629 (char *) "self", NULL
4630 };
4631
4632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4634 if (SWIG_arg_fail(1)) SWIG_fail;
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 result = (arg1)->GetValue();
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 #if wxUSE_UNICODE
4644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4645 #else
4646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4647 #endif
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4656 PyObject *obj;
4657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4658 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4659 Py_INCREF(obj);
4660 return Py_BuildValue((char *)"");
4661 }
4662 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 int arg1 = (int) -1 ;
4665 int arg2 = (int) -1 ;
4666 wxGridCellFloatEditor *result;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "width",(char *) "precision", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4674 if (obj0) {
4675 {
4676 arg1 = (int)(SWIG_As_int(obj0));
4677 if (SWIG_arg_fail(1)) SWIG_fail;
4678 }
4679 }
4680 if (obj1) {
4681 {
4682 arg2 = (int)(SWIG_As_int(obj1));
4683 if (SWIG_arg_fail(2)) SWIG_fail;
4684 }
4685 }
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4689
4690 wxPyEndAllowThreads(__tstate);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj;
4702 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4703 wxString result;
4704 PyObject * obj0 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (arg1)->GetValue();
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 {
4720 #if wxUSE_UNICODE
4721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4722 #else
4723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4724 #endif
4725 }
4726 return resultobj;
4727 fail:
4728 return NULL;
4729 }
4730
4731
4732 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4733 PyObject *obj;
4734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4735 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4736 Py_INCREF(obj);
4737 return Py_BuildValue((char *)"");
4738 }
4739 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4740 PyObject *resultobj;
4741 wxGridCellBoolEditor *result;
4742 char *kwnames[] = {
4743 NULL
4744 };
4745
4746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4750
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj;
4763 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4764 wxString result;
4765 PyObject * obj0 = 0 ;
4766 char *kwnames[] = {
4767 (char *) "self", NULL
4768 };
4769
4770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4772 if (SWIG_arg_fail(1)) SWIG_fail;
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (arg1)->GetValue();
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 {
4781 #if wxUSE_UNICODE
4782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4783 #else
4784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4785 #endif
4786 }
4787 return resultobj;
4788 fail:
4789 return NULL;
4790 }
4791
4792
4793 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
4794 PyObject *obj;
4795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4796 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
4797 Py_INCREF(obj);
4798 return Py_BuildValue((char *)"");
4799 }
4800 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj;
4802 int arg1 = (int) 0 ;
4803 wxString *arg2 = (wxString *) NULL ;
4804 bool arg3 = (bool) false ;
4805 wxGridCellChoiceEditor *result;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char *kwnames[] = {
4809 (char *) "choices",(char *) "allowOthers", NULL
4810 };
4811
4812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
4813 if (obj0) {
4814 {
4815 arg1 = PyList_Size(obj0);
4816 arg2 = wxString_LIST_helper(obj0);
4817 if (arg2 == NULL) SWIG_fail;
4818 }
4819 }
4820 if (obj1) {
4821 {
4822 arg3 = (bool)(SWIG_As_bool(obj1));
4823 if (SWIG_arg_fail(3)) SWIG_fail;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
4829
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
4834 {
4835 if (arg2) delete [] arg2;
4836 }
4837 return resultobj;
4838 fail:
4839 {
4840 if (arg2) delete [] arg2;
4841 }
4842 return NULL;
4843 }
4844
4845
4846 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj;
4848 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
4849 wxString result;
4850 PyObject * obj0 = 0 ;
4851 char *kwnames[] = {
4852 (char *) "self", NULL
4853 };
4854
4855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
4856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
4857 if (SWIG_arg_fail(1)) SWIG_fail;
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 result = (arg1)->GetValue();
4861
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 {
4866 #if wxUSE_UNICODE
4867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4868 #else
4869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4870 #endif
4871 }
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
4879 PyObject *obj;
4880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4881 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
4882 Py_INCREF(obj);
4883 return Py_BuildValue((char *)"");
4884 }
4885 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj;
4887 wxString const &arg1_defvalue = wxPyEmptyString ;
4888 wxString *arg1 = (wxString *) &arg1_defvalue ;
4889 wxGridCellEnumEditor *result;
4890 bool temp1 = false ;
4891 PyObject * obj0 = 0 ;
4892 char *kwnames[] = {
4893 (char *) "choices", NULL
4894 };
4895
4896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
4897 if (obj0) {
4898 {
4899 arg1 = wxString_in_helper(obj0);
4900 if (arg1 == NULL) SWIG_fail;
4901 temp1 = true;
4902 }
4903 }
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
4907
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
4912 {
4913 if (temp1)
4914 delete arg1;
4915 }
4916 return resultobj;
4917 fail:
4918 {
4919 if (temp1)
4920 delete arg1;
4921 }
4922 return NULL;
4923 }
4924
4925
4926 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4927 PyObject *resultobj;
4928 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
4929 wxString result;
4930 PyObject * obj0 = 0 ;
4931 char *kwnames[] = {
4932 (char *) "self", NULL
4933 };
4934
4935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
4936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
4937 if (SWIG_arg_fail(1)) SWIG_fail;
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (arg1)->GetValue();
4941
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 {
4946 #if wxUSE_UNICODE
4947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4948 #else
4949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4950 #endif
4951 }
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
4958 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
4959 PyObject *obj;
4960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4961 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
4962 Py_INCREF(obj);
4963 return Py_BuildValue((char *)"");
4964 }
4965 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxGridCellAutoWrapStringEditor *result;
4968 char *kwnames[] = {
4969 NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
4976
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
4990 wxString result;
4991 PyObject * obj0 = 0 ;
4992 char *kwnames[] = {
4993 (char *) "self", NULL
4994 };
4995
4996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
4997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
4998 if (SWIG_arg_fail(1)) SWIG_fail;
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 result = (arg1)->GetValue();
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 {
5007 #if wxUSE_UNICODE
5008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5009 #else
5010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5011 #endif
5012 }
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5020 PyObject *obj;
5021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5022 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5023 Py_INCREF(obj);
5024 return Py_BuildValue((char *)"");
5025 }
5026 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5029 PyObject *arg2 = (PyObject *) 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 char *kwnames[] = {
5033 (char *) "self",(char *) "_self", NULL
5034 };
5035
5036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5038 if (SWIG_arg_fail(1)) SWIG_fail;
5039 arg2 = obj1;
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 wxGridCellAttr__setOORInfo(arg1,arg2);
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 Py_INCREF(Py_None); resultobj = Py_None;
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5057 wxGridCellAttr *result;
5058 PyObject * obj0 = 0 ;
5059 char *kwnames[] = {
5060 (char *) "attrDefault", NULL
5061 };
5062
5063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5064 if (obj0) {
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 resultobj = wxPyMake_wxGridCellAttr(result, 1);
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5087 wxGridCellAttr *result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 resultobj = wxPyMake_wxGridCellAttr(result, 0);
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj;
5114 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5115 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 char *kwnames[] = {
5119 (char *) "self",(char *) "mergefrom", NULL
5120 };
5121
5122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5124 if (SWIG_arg_fail(1)) SWIG_fail;
5125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(2)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->MergeWith(arg2);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 Py_INCREF(Py_None); resultobj = Py_None;
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
5143 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5144 PyObject * obj0 = 0 ;
5145 char *kwnames[] = {
5146 (char *) "self", NULL
5147 };
5148
5149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5151 if (SWIG_arg_fail(1)) SWIG_fail;
5152 {
5153 PyThreadState* __tstate = wxPyBeginAllowThreads();
5154 (arg1)->IncRef();
5155
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 Py_INCREF(Py_None); resultobj = Py_None;
5160 return resultobj;
5161 fail:
5162 return NULL;
5163 }
5164
5165
5166 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5167 PyObject *resultobj;
5168 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5169 PyObject * obj0 = 0 ;
5170 char *kwnames[] = {
5171 (char *) "self", NULL
5172 };
5173
5174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5176 if (SWIG_arg_fail(1)) SWIG_fail;
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 (arg1)->DecRef();
5180
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 Py_INCREF(Py_None); resultobj = Py_None;
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj;
5193 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5194 wxColour *arg2 = 0 ;
5195 wxColour temp2 ;
5196 PyObject * obj0 = 0 ;
5197 PyObject * obj1 = 0 ;
5198 char *kwnames[] = {
5199 (char *) "self",(char *) "colText", NULL
5200 };
5201
5202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5204 if (SWIG_arg_fail(1)) SWIG_fail;
5205 {
5206 arg2 = &temp2;
5207 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5208 }
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 (arg1)->SetTextColour((wxColour const &)*arg2);
5212
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 Py_INCREF(Py_None); resultobj = Py_None;
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj;
5225 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5226 wxColour *arg2 = 0 ;
5227 wxColour temp2 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char *kwnames[] = {
5231 (char *) "self",(char *) "colBack", NULL
5232 };
5233
5234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5236 if (SWIG_arg_fail(1)) SWIG_fail;
5237 {
5238 arg2 = &temp2;
5239 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5240 }
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5244
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 Py_INCREF(Py_None); resultobj = Py_None;
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 static PyObject *_wrap_GridCellAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj;
5257 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5258 wxFont *arg2 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 PyObject * obj1 = 0 ;
5261 char *kwnames[] = {
5262 (char *) "self",(char *) "font", NULL
5263 };
5264
5265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5267 if (SWIG_arg_fail(1)) SWIG_fail;
5268 {
5269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5270 if (SWIG_arg_fail(2)) SWIG_fail;
5271 if (arg2 == NULL) {
5272 SWIG_null_ref("wxFont");
5273 }
5274 if (SWIG_arg_fail(2)) SWIG_fail;
5275 }
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 (arg1)->SetFont((wxFont const &)*arg2);
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 Py_INCREF(Py_None); resultobj = Py_None;
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5291 PyObject *resultobj;
5292 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5293 int arg2 ;
5294 int arg3 ;
5295 PyObject * obj0 = 0 ;
5296 PyObject * obj1 = 0 ;
5297 PyObject * obj2 = 0 ;
5298 char *kwnames[] = {
5299 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5300 };
5301
5302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5304 if (SWIG_arg_fail(1)) SWIG_fail;
5305 {
5306 arg2 = (int)(SWIG_As_int(obj1));
5307 if (SWIG_arg_fail(2)) SWIG_fail;
5308 }
5309 {
5310 arg3 = (int)(SWIG_As_int(obj2));
5311 if (SWIG_arg_fail(3)) SWIG_fail;
5312 }
5313 {
5314 PyThreadState* __tstate = wxPyBeginAllowThreads();
5315 (arg1)->SetAlignment(arg2,arg3);
5316
5317 wxPyEndAllowThreads(__tstate);
5318 if (PyErr_Occurred()) SWIG_fail;
5319 }
5320 Py_INCREF(Py_None); resultobj = Py_None;
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5328 PyObject *resultobj;
5329 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5330 int arg2 ;
5331 int arg3 ;
5332 PyObject * obj0 = 0 ;
5333 PyObject * obj1 = 0 ;
5334 PyObject * obj2 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 arg2 = (int)(SWIG_As_int(obj1));
5344 if (SWIG_arg_fail(2)) SWIG_fail;
5345 }
5346 {
5347 arg3 = (int)(SWIG_As_int(obj2));
5348 if (SWIG_arg_fail(3)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetSize(arg2,arg3);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5367 bool arg2 = (bool) true ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "allow", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 if (obj1) {
5378 {
5379 arg2 = (bool)(SWIG_As_bool(obj1));
5380 if (SWIG_arg_fail(2)) SWIG_fail;
5381 }
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetOverflow(arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5400 bool arg2 = (bool) true ;
5401 PyObject * obj0 = 0 ;
5402 PyObject * obj1 = 0 ;
5403 char *kwnames[] = {
5404 (char *) "self",(char *) "isReadOnly", NULL
5405 };
5406
5407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5409 if (SWIG_arg_fail(1)) SWIG_fail;
5410 if (obj1) {
5411 {
5412 arg2 = (bool)(SWIG_As_bool(obj1));
5413 if (SWIG_arg_fail(2)) SWIG_fail;
5414 }
5415 }
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 (arg1)->SetReadOnly(arg2);
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 Py_INCREF(Py_None); resultobj = Py_None;
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5431 PyObject *resultobj;
5432 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5433 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5434 PyObject * obj0 = 0 ;
5435 PyObject * obj1 = 0 ;
5436 char *kwnames[] = {
5437 (char *) "self",(char *) "renderer", NULL
5438 };
5439
5440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5442 if (SWIG_arg_fail(1)) SWIG_fail;
5443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5444 if (SWIG_arg_fail(2)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->SetRenderer(arg2);
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 Py_INCREF(Py_None); resultobj = Py_None;
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5462 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char *kwnames[] = {
5466 (char *) "self",(char *) "editor", NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5471 if (SWIG_arg_fail(1)) SWIG_fail;
5472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(2)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 (arg1)->SetEditor(arg2);
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 Py_INCREF(Py_None); resultobj = Py_None;
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj;
5490 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5491 wxGridCellAttr::wxAttrKind arg2 ;
5492 PyObject * obj0 = 0 ;
5493 PyObject * obj1 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self",(char *) "kind", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 arg2 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj1));
5503 if (SWIG_arg_fail(2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 (arg1)->SetKind((wxGridCellAttr::wxAttrKind )arg2);
5508
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 Py_INCREF(Py_None); resultobj = Py_None;
5513 return resultobj;
5514 fail:
5515 return NULL;
5516 }
5517
5518
5519 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5520 PyObject *resultobj;
5521 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5522 bool result;
5523 PyObject * obj0 = 0 ;
5524 char *kwnames[] = {
5525 (char *) "self", NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5530 if (SWIG_arg_fail(1)) SWIG_fail;
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 {
5539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5540 }
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj;
5549 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5550 bool result;
5551 PyObject * obj0 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5562
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 {
5567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5568 }
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj;
5577 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5578 bool result;
5579 PyObject * obj0 = 0 ;
5580 char *kwnames[] = {
5581 (char *) "self", NULL
5582 };
5583
5584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5586 if (SWIG_arg_fail(1)) SWIG_fail;
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5590
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 {
5595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5596 }
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj;
5605 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5606 bool result;
5607 PyObject * obj0 = 0 ;
5608 char *kwnames[] = {
5609 (char *) "self", NULL
5610 };
5611
5612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5614 if (SWIG_arg_fail(1)) SWIG_fail;
5615 {
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 {
5623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5624 }
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj;
5633 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5634 bool result;
5635 PyObject * obj0 = 0 ;
5636 char *kwnames[] = {
5637 (char *) "self", NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5642 if (SWIG_arg_fail(1)) SWIG_fail;
5643 {
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 {
5651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5652 }
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj;
5661 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5662 bool result;
5663 PyObject * obj0 = 0 ;
5664 char *kwnames[] = {
5665 (char *) "self", NULL
5666 };
5667
5668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5670 if (SWIG_arg_fail(1)) SWIG_fail;
5671 {
5672 PyThreadState* __tstate = wxPyBeginAllowThreads();
5673 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5674
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 {
5679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5680 }
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj;
5689 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5690 bool result;
5691 PyObject * obj0 = 0 ;
5692 char *kwnames[] = {
5693 (char *) "self", NULL
5694 };
5695
5696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5698 if (SWIG_arg_fail(1)) SWIG_fail;
5699 {
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5702
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 {
5707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5708 }
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5718 bool result;
5719 PyObject * obj0 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 {
5735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5736 }
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5746 wxColour result;
5747 PyObject * obj0 = 0 ;
5748 char *kwnames[] = {
5749 (char *) "self", NULL
5750 };
5751
5752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5754 if (SWIG_arg_fail(1)) SWIG_fail;
5755 {
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 {
5763 wxColour * resultptr;
5764 resultptr = new wxColour((wxColour &)(result));
5765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5766 }
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5776 wxColour result;
5777 PyObject * obj0 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "self", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
5783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5784 if (SWIG_arg_fail(1)) SWIG_fail;
5785 {
5786 PyThreadState* __tstate = wxPyBeginAllowThreads();
5787 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
5788
5789 wxPyEndAllowThreads(__tstate);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 {
5793 wxColour * resultptr;
5794 resultptr = new wxColour((wxColour &)(result));
5795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5796 }
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj;
5805 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5806 wxFont result;
5807 PyObject * obj0 = 0 ;
5808 char *kwnames[] = {
5809 (char *) "self", NULL
5810 };
5811
5812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
5813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5814 if (SWIG_arg_fail(1)) SWIG_fail;
5815 {
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = ((wxGridCellAttr const *)arg1)->GetFont();
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 wxFont * resultptr;
5824 resultptr = new wxFont((wxFont &)(result));
5825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5836 int *arg2 = (int *) 0 ;
5837 int *arg3 = (int *) 0 ;
5838 int temp2 ;
5839 int res2 = 0 ;
5840 int temp3 ;
5841 int res3 = 0 ;
5842 PyObject * obj0 = 0 ;
5843 char *kwnames[] = {
5844 (char *) "self", NULL
5845 };
5846
5847 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5848 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
5855
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 Py_INCREF(Py_None); resultobj = Py_None;
5860 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5861 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5862 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5863 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj;
5872 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5873 int *arg2 = (int *) 0 ;
5874 int *arg3 = (int *) 0 ;
5875 int temp2 ;
5876 int res2 = 0 ;
5877 int temp3 ;
5878 int res3 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 char *kwnames[] = {
5881 (char *) "self", NULL
5882 };
5883
5884 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5885 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
5892
5893 wxPyEndAllowThreads(__tstate);
5894 if (PyErr_Occurred()) SWIG_fail;
5895 }
5896 Py_INCREF(Py_None); resultobj = Py_None;
5897 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5898 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5899 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5900 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj;
5909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5910 bool result;
5911 PyObject * obj0 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "self", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
5917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5918 if (SWIG_arg_fail(1)) SWIG_fail;
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5928 }
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5938 wxGrid *arg2 = (wxGrid *) 0 ;
5939 int arg3 ;
5940 int arg4 ;
5941 wxGridCellRenderer *result;
5942 PyObject * obj0 = 0 ;
5943 PyObject * obj1 = 0 ;
5944 PyObject * obj2 = 0 ;
5945 PyObject * obj3 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(2)) SWIG_fail;
5955 {
5956 arg3 = (int)(SWIG_As_int(obj2));
5957 if (SWIG_arg_fail(3)) SWIG_fail;
5958 }
5959 {
5960 arg4 = (int)(SWIG_As_int(obj3));
5961 if (SWIG_arg_fail(4)) SWIG_fail;
5962 }
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
5966
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj;
5981 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5982 wxGrid *arg2 = (wxGrid *) 0 ;
5983 int arg3 ;
5984 int arg4 ;
5985 wxGridCellEditor *result;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 PyObject * obj2 = 0 ;
5989 PyObject * obj3 = 0 ;
5990 char *kwnames[] = {
5991 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
5992 };
5993
5994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5996 if (SWIG_arg_fail(1)) SWIG_fail;
5997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
5998 if (SWIG_arg_fail(2)) SWIG_fail;
5999 {
6000 arg3 = (int)(SWIG_As_int(obj2));
6001 if (SWIG_arg_fail(3)) SWIG_fail;
6002 }
6003 {
6004 arg4 = (int)(SWIG_As_int(obj3));
6005 if (SWIG_arg_fail(4)) SWIG_fail;
6006 }
6007 {
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6010
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 {
6015 resultobj = wxPyMake_wxGridCellEditor(result, 0);
6016 }
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6026 bool result;
6027 PyObject * obj0 = 0 ;
6028 char *kwnames[] = {
6029 (char *) "self", NULL
6030 };
6031
6032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6034 if (SWIG_arg_fail(1)) SWIG_fail;
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 {
6043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6044 }
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj;
6053 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6054 wxGridCellAttr::wxAttrKind result;
6055 PyObject * obj0 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "self", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6062 if (SWIG_arg_fail(1)) SWIG_fail;
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6066
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 resultobj = SWIG_From_int((result));
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj;
6079 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6080 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "defAttr", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(2)) SWIG_fail;
6092 {
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 (arg1)->SetDefAttr(arg2);
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 Py_INCREF(Py_None); resultobj = Py_None;
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6107 PyObject *obj;
6108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6109 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6110 Py_INCREF(obj);
6111 return Py_BuildValue((char *)"");
6112 }
6113 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj;
6115 wxGridCellAttrProvider *result;
6116 char *kwnames[] = {
6117 NULL
6118 };
6119
6120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 resultobj = wxPyMake_wxGridCellAttrProvider(result, 1);
6130 }
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj;
6139 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6140 PyObject *arg2 = (PyObject *) 0 ;
6141 PyObject * obj0 = 0 ;
6142 PyObject * obj1 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "self",(char *) "_self", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6149 if (SWIG_arg_fail(1)) SWIG_fail;
6150 arg2 = obj1;
6151 {
6152 PyThreadState* __tstate = wxPyBeginAllowThreads();
6153 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6154
6155 wxPyEndAllowThreads(__tstate);
6156 if (PyErr_Occurred()) SWIG_fail;
6157 }
6158 Py_INCREF(Py_None); resultobj = Py_None;
6159 return resultobj;
6160 fail:
6161 return NULL;
6162 }
6163
6164
6165 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6166 PyObject *resultobj;
6167 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6168 int arg2 ;
6169 int arg3 ;
6170 wxGridCellAttr::wxAttrKind arg4 ;
6171 wxGridCellAttr *result;
6172 PyObject * obj0 = 0 ;
6173 PyObject * obj1 = 0 ;
6174 PyObject * obj2 = 0 ;
6175 PyObject * obj3 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 {
6184 arg2 = (int)(SWIG_As_int(obj1));
6185 if (SWIG_arg_fail(2)) SWIG_fail;
6186 }
6187 {
6188 arg3 = (int)(SWIG_As_int(obj2));
6189 if (SWIG_arg_fail(3)) SWIG_fail;
6190 }
6191 {
6192 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6193 if (SWIG_arg_fail(4)) SWIG_fail;
6194 }
6195 {
6196 PyThreadState* __tstate = wxPyBeginAllowThreads();
6197 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6198
6199 wxPyEndAllowThreads(__tstate);
6200 if (PyErr_Occurred()) SWIG_fail;
6201 }
6202 {
6203 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6204 }
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6214 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6215 int arg3 ;
6216 int arg4 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 PyObject * obj3 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6229 if (SWIG_arg_fail(2)) SWIG_fail;
6230 {
6231 arg3 = (int)(SWIG_As_int(obj2));
6232 if (SWIG_arg_fail(3)) SWIG_fail;
6233 }
6234 {
6235 arg4 = (int)(SWIG_As_int(obj3));
6236 if (SWIG_arg_fail(4)) SWIG_fail;
6237 }
6238 {
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 (arg1)->SetAttr(arg2,arg3,arg4);
6241
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 Py_INCREF(Py_None); resultobj = Py_None;
6246 return resultobj;
6247 fail:
6248 return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6253 PyObject *resultobj;
6254 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6255 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6256 int arg3 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 PyObject * obj2 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self",(char *) "attr",(char *) "row", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6268 if (SWIG_arg_fail(2)) SWIG_fail;
6269 {
6270 arg3 = (int)(SWIG_As_int(obj2));
6271 if (SWIG_arg_fail(3)) SWIG_fail;
6272 }
6273 {
6274 PyThreadState* __tstate = wxPyBeginAllowThreads();
6275 (arg1)->SetRowAttr(arg2,arg3);
6276
6277 wxPyEndAllowThreads(__tstate);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 Py_INCREF(Py_None); resultobj = Py_None;
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj;
6289 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6290 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6291 int arg3 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 PyObject * obj2 = 0 ;
6295 char *kwnames[] = {
6296 (char *) "self",(char *) "attr",(char *) "col", NULL
6297 };
6298
6299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6303 if (SWIG_arg_fail(2)) SWIG_fail;
6304 {
6305 arg3 = (int)(SWIG_As_int(obj2));
6306 if (SWIG_arg_fail(3)) SWIG_fail;
6307 }
6308 {
6309 PyThreadState* __tstate = wxPyBeginAllowThreads();
6310 (arg1)->SetColAttr(arg2,arg3);
6311
6312 wxPyEndAllowThreads(__tstate);
6313 if (PyErr_Occurred()) SWIG_fail;
6314 }
6315 Py_INCREF(Py_None); resultobj = Py_None;
6316 return resultobj;
6317 fail:
6318 return NULL;
6319 }
6320
6321
6322 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj;
6324 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6325 size_t arg2 ;
6326 int arg3 ;
6327 PyObject * obj0 = 0 ;
6328 PyObject * obj1 = 0 ;
6329 PyObject * obj2 = 0 ;
6330 char *kwnames[] = {
6331 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6332 };
6333
6334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6336 if (SWIG_arg_fail(1)) SWIG_fail;
6337 {
6338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6339 if (SWIG_arg_fail(2)) SWIG_fail;
6340 }
6341 {
6342 arg3 = (int)(SWIG_As_int(obj2));
6343 if (SWIG_arg_fail(3)) SWIG_fail;
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 (arg1)->UpdateAttrRows(arg2,arg3);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6362 size_t arg2 ;
6363 int arg3 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 PyObject * obj2 = 0 ;
6367 char *kwnames[] = {
6368 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6369 };
6370
6371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6373 if (SWIG_arg_fail(1)) SWIG_fail;
6374 {
6375 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
6376 if (SWIG_arg_fail(2)) SWIG_fail;
6377 }
6378 {
6379 arg3 = (int)(SWIG_As_int(obj2));
6380 if (SWIG_arg_fail(3)) SWIG_fail;
6381 }
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->UpdateAttrCols(arg2,arg3);
6385
6386 wxPyEndAllowThreads(__tstate);
6387 if (PyErr_Occurred()) SWIG_fail;
6388 }
6389 Py_INCREF(Py_None); resultobj = Py_None;
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6397 PyObject *obj;
6398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6399 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6400 Py_INCREF(obj);
6401 return Py_BuildValue((char *)"");
6402 }
6403 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 wxPyGridCellAttrProvider *result;
6406 char *kwnames[] = {
6407 NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6428 PyObject *arg2 = (PyObject *) 0 ;
6429 PyObject *arg3 = (PyObject *) 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 PyObject * obj2 = 0 ;
6433 char *kwnames[] = {
6434 (char *) "self",(char *) "self",(char *) "_class", NULL
6435 };
6436
6437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6439 if (SWIG_arg_fail(1)) SWIG_fail;
6440 arg2 = obj1;
6441 arg3 = obj2;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->_setCallbackInfo(arg2,arg3);
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 Py_INCREF(Py_None); resultobj = Py_None;
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject *_wrap_PyGridCellAttrProvider_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6459 int arg2 ;
6460 int arg3 ;
6461 wxGridCellAttr::wxAttrKind arg4 ;
6462 wxGridCellAttr *result;
6463 PyObject * obj0 = 0 ;
6464 PyObject * obj1 = 0 ;
6465 PyObject * obj2 = 0 ;
6466 PyObject * obj3 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6473 if (SWIG_arg_fail(1)) SWIG_fail;
6474 {
6475 arg2 = (int)(SWIG_As_int(obj1));
6476 if (SWIG_arg_fail(2)) SWIG_fail;
6477 }
6478 {
6479 arg3 = (int)(SWIG_As_int(obj2));
6480 if (SWIG_arg_fail(3)) SWIG_fail;
6481 }
6482 {
6483 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
6484 if (SWIG_arg_fail(4)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
6489
6490 wxPyEndAllowThreads(__tstate);
6491 if (PyErr_Occurred()) SWIG_fail;
6492 }
6493 {
6494 resultobj = wxPyMake_wxGridCellAttr(result, 0);
6495 }
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_PyGridCellAttrProvider_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6505 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6506 int arg3 ;
6507 int arg4 ;
6508 PyObject * obj0 = 0 ;
6509 PyObject * obj1 = 0 ;
6510 PyObject * obj2 = 0 ;
6511 PyObject * obj3 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(2)) SWIG_fail;
6521 {
6522 arg3 = (int)(SWIG_As_int(obj2));
6523 if (SWIG_arg_fail(3)) SWIG_fail;
6524 }
6525 {
6526 arg4 = (int)(SWIG_As_int(obj3));
6527 if (SWIG_arg_fail(4)) SWIG_fail;
6528 }
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->base_SetAttr(arg2,arg3,arg4);
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 Py_INCREF(Py_None); resultobj = Py_None;
6537 return resultobj;
6538 fail:
6539 return NULL;
6540 }
6541
6542
6543 static PyObject *_wrap_PyGridCellAttrProvider_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj;
6545 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6546 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6547 int arg3 ;
6548 PyObject * obj0 = 0 ;
6549 PyObject * obj1 = 0 ;
6550 PyObject * obj2 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self",(char *) "attr",(char *) "row", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 {
6561 arg3 = (int)(SWIG_As_int(obj2));
6562 if (SWIG_arg_fail(3)) SWIG_fail;
6563 }
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 (arg1)->base_SetRowAttr(arg2,arg3);
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 Py_INCREF(Py_None); resultobj = Py_None;
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 static PyObject *_wrap_PyGridCellAttrProvider_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6579 PyObject *resultobj;
6580 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6581 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6582 int arg3 ;
6583 PyObject * obj0 = 0 ;
6584 PyObject * obj1 = 0 ;
6585 PyObject * obj2 = 0 ;
6586 char *kwnames[] = {
6587 (char *) "self",(char *) "attr",(char *) "col", NULL
6588 };
6589
6590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6592 if (SWIG_arg_fail(1)) SWIG_fail;
6593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6594 if (SWIG_arg_fail(2)) SWIG_fail;
6595 {
6596 arg3 = (int)(SWIG_As_int(obj2));
6597 if (SWIG_arg_fail(3)) SWIG_fail;
6598 }
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 (arg1)->base_SetColAttr(arg2,arg3);
6602
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 Py_INCREF(Py_None); resultobj = Py_None;
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6614 PyObject *obj;
6615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6616 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6617 Py_INCREF(obj);
6618 return Py_BuildValue((char *)"");
6619 }
6620 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6623 PyObject *arg2 = (PyObject *) 0 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self",(char *) "_self", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 arg2 = obj1;
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 wxGridTableBase__setOORInfo(arg1,arg2);
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 Py_INCREF(Py_None); resultobj = Py_None;
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6651 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 char *kwnames[] = {
6655 (char *) "self",(char *) "attrProvider", NULL
6656 };
6657
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(2)) SWIG_fail;
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 (arg1)->SetAttrProvider(arg2);
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 Py_INCREF(Py_None); resultobj = Py_None;
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6680 wxGridCellAttrProvider *result;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 {
6697 resultobj = wxPyMake_wxGridCellAttrProvider(result, 0);
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6708 wxGrid *arg2 = (wxGrid *) 0 ;
6709 PyObject * obj0 = 0 ;
6710 PyObject * obj1 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "grid", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(2)) SWIG_fail;
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->SetView(arg2);
6723
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 Py_INCREF(Py_None); resultobj = Py_None;
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6737 wxGrid *result;
6738 PyObject * obj0 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6749
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 {
6754 resultobj = wxPyMake_wxObject(result, 0);
6755 }
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6763 PyObject *resultobj;
6764 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6765 int result;
6766 PyObject * obj0 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "self", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = (int)(arg1)->GetNumberRows();
6777
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 {
6782 resultobj = SWIG_From_int((int)(result));
6783 }
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6793 int result;
6794 PyObject * obj0 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (int)(arg1)->GetNumberCols();
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 {
6810 resultobj = SWIG_From_int((int)(result));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj;
6820 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6821 int arg2 ;
6822 int arg3 ;
6823 bool result;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 PyObject * obj2 = 0 ;
6827 char *kwnames[] = {
6828 (char *) "self",(char *) "row",(char *) "col", NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
6832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6833 if (SWIG_arg_fail(1)) SWIG_fail;
6834 {
6835 arg2 = (int)(SWIG_As_int(obj1));
6836 if (SWIG_arg_fail(2)) SWIG_fail;
6837 }
6838 {
6839 arg3 = (int)(SWIG_As_int(obj2));
6840 if (SWIG_arg_fail(3)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj;
6860 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6861 int arg2 ;
6862 int arg3 ;
6863 wxString result;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 PyObject * obj2 = 0 ;
6867 char *kwnames[] = {
6868 (char *) "self",(char *) "row",(char *) "col", NULL
6869 };
6870
6871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
6872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6873 if (SWIG_arg_fail(1)) SWIG_fail;
6874 {
6875 arg2 = (int)(SWIG_As_int(obj1));
6876 if (SWIG_arg_fail(2)) SWIG_fail;
6877 }
6878 {
6879 arg3 = (int)(SWIG_As_int(obj2));
6880 if (SWIG_arg_fail(3)) SWIG_fail;
6881 }
6882 {
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 result = (arg1)->GetValue(arg2,arg3);
6885
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 {
6890 #if wxUSE_UNICODE
6891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6892 #else
6893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6894 #endif
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6905 int arg2 ;
6906 int arg3 ;
6907 wxString *arg4 = 0 ;
6908 bool temp4 = false ;
6909 PyObject * obj0 = 0 ;
6910 PyObject * obj1 = 0 ;
6911 PyObject * obj2 = 0 ;
6912 PyObject * obj3 = 0 ;
6913 char *kwnames[] = {
6914 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
6915 };
6916
6917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(1)) SWIG_fail;
6920 {
6921 arg2 = (int)(SWIG_As_int(obj1));
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 arg3 = (int)(SWIG_As_int(obj2));
6926 if (SWIG_arg_fail(3)) SWIG_fail;
6927 }
6928 {
6929 arg4 = wxString_in_helper(obj3);
6930 if (arg4 == NULL) SWIG_fail;
6931 temp4 = true;
6932 }
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 {
6942 if (temp4)
6943 delete arg4;
6944 }
6945 return resultobj;
6946 fail:
6947 {
6948 if (temp4)
6949 delete arg4;
6950 }
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6958 int arg2 ;
6959 int arg3 ;
6960 wxString result;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 PyObject * obj2 = 0 ;
6964 char *kwnames[] = {
6965 (char *) "self",(char *) "row",(char *) "col", NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
6969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6970 if (SWIG_arg_fail(1)) SWIG_fail;
6971 {
6972 arg2 = (int)(SWIG_As_int(obj1));
6973 if (SWIG_arg_fail(2)) SWIG_fail;
6974 }
6975 {
6976 arg3 = (int)(SWIG_As_int(obj2));
6977 if (SWIG_arg_fail(3)) SWIG_fail;
6978 }
6979 {
6980 PyThreadState* __tstate = wxPyBeginAllowThreads();
6981 result = (arg1)->GetTypeName(arg2,arg3);
6982
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 {
6987 #if wxUSE_UNICODE
6988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6989 #else
6990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6991 #endif
6992 }
6993 return resultobj;
6994 fail:
6995 return NULL;
6996 }
6997
6998
6999 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7000 PyObject *resultobj;
7001 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7002 int arg2 ;
7003 int arg3 ;
7004 wxString *arg4 = 0 ;
7005 bool result;
7006 bool temp4 = false ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 PyObject * obj2 = 0 ;
7010 PyObject * obj3 = 0 ;
7011 char *kwnames[] = {
7012 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7013 };
7014
7015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7017 if (SWIG_arg_fail(1)) SWIG_fail;
7018 {
7019 arg2 = (int)(SWIG_As_int(obj1));
7020 if (SWIG_arg_fail(2)) SWIG_fail;
7021 }
7022 {
7023 arg3 = (int)(SWIG_As_int(obj2));
7024 if (SWIG_arg_fail(3)) SWIG_fail;
7025 }
7026 {
7027 arg4 = wxString_in_helper(obj3);
7028 if (arg4 == NULL) SWIG_fail;
7029 temp4 = true;
7030 }
7031 {
7032 PyThreadState* __tstate = wxPyBeginAllowThreads();
7033 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7034
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 {
7039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7040 }
7041 {
7042 if (temp4)
7043 delete arg4;
7044 }
7045 return resultobj;
7046 fail:
7047 {
7048 if (temp4)
7049 delete arg4;
7050 }
7051 return NULL;
7052 }
7053
7054
7055 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj;
7057 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7058 int arg2 ;
7059 int arg3 ;
7060 wxString *arg4 = 0 ;
7061 bool result;
7062 bool temp4 = false ;
7063 PyObject * obj0 = 0 ;
7064 PyObject * obj1 = 0 ;
7065 PyObject * obj2 = 0 ;
7066 PyObject * obj3 = 0 ;
7067 char *kwnames[] = {
7068 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7069 };
7070
7071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7073 if (SWIG_arg_fail(1)) SWIG_fail;
7074 {
7075 arg2 = (int)(SWIG_As_int(obj1));
7076 if (SWIG_arg_fail(2)) SWIG_fail;
7077 }
7078 {
7079 arg3 = (int)(SWIG_As_int(obj2));
7080 if (SWIG_arg_fail(3)) SWIG_fail;
7081 }
7082 {
7083 arg4 = wxString_in_helper(obj3);
7084 if (arg4 == NULL) SWIG_fail;
7085 temp4 = true;
7086 }
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 {
7095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7096 }
7097 {
7098 if (temp4)
7099 delete arg4;
7100 }
7101 return resultobj;
7102 fail:
7103 {
7104 if (temp4)
7105 delete arg4;
7106 }
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj;
7113 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7114 int arg2 ;
7115 int arg3 ;
7116 long result;
7117 PyObject * obj0 = 0 ;
7118 PyObject * obj1 = 0 ;
7119 PyObject * obj2 = 0 ;
7120 char *kwnames[] = {
7121 (char *) "self",(char *) "row",(char *) "col", NULL
7122 };
7123
7124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7126 if (SWIG_arg_fail(1)) SWIG_fail;
7127 {
7128 arg2 = (int)(SWIG_As_int(obj1));
7129 if (SWIG_arg_fail(2)) SWIG_fail;
7130 }
7131 {
7132 arg3 = (int)(SWIG_As_int(obj2));
7133 if (SWIG_arg_fail(3)) SWIG_fail;
7134 }
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7138
7139 wxPyEndAllowThreads(__tstate);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 {
7143 resultobj = SWIG_From_long((long)(result));
7144 }
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7152 PyObject *resultobj;
7153 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7154 int arg2 ;
7155 int arg3 ;
7156 double result;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 PyObject * obj2 = 0 ;
7160 char *kwnames[] = {
7161 (char *) "self",(char *) "row",(char *) "col", NULL
7162 };
7163
7164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7166 if (SWIG_arg_fail(1)) SWIG_fail;
7167 {
7168 arg2 = (int)(SWIG_As_int(obj1));
7169 if (SWIG_arg_fail(2)) SWIG_fail;
7170 }
7171 {
7172 arg3 = (int)(SWIG_As_int(obj2));
7173 if (SWIG_arg_fail(3)) SWIG_fail;
7174 }
7175 {
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7178
7179 wxPyEndAllowThreads(__tstate);
7180 if (PyErr_Occurred()) SWIG_fail;
7181 }
7182 {
7183 resultobj = SWIG_From_double((double)(result));
7184 }
7185 return resultobj;
7186 fail:
7187 return NULL;
7188 }
7189
7190
7191 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7192 PyObject *resultobj;
7193 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7194 int arg2 ;
7195 int arg3 ;
7196 bool result;
7197 PyObject * obj0 = 0 ;
7198 PyObject * obj1 = 0 ;
7199 PyObject * obj2 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self",(char *) "row",(char *) "col", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 {
7208 arg2 = (int)(SWIG_As_int(obj1));
7209 if (SWIG_arg_fail(2)) SWIG_fail;
7210 }
7211 {
7212 arg3 = (int)(SWIG_As_int(obj2));
7213 if (SWIG_arg_fail(3)) SWIG_fail;
7214 }
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7218
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 {
7223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7224 }
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj;
7233 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7234 int arg2 ;
7235 int arg3 ;
7236 long arg4 ;
7237 PyObject * obj0 = 0 ;
7238 PyObject * obj1 = 0 ;
7239 PyObject * obj2 = 0 ;
7240 PyObject * obj3 = 0 ;
7241 char *kwnames[] = {
7242 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7243 };
7244
7245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7247 if (SWIG_arg_fail(1)) SWIG_fail;
7248 {
7249 arg2 = (int)(SWIG_As_int(obj1));
7250 if (SWIG_arg_fail(2)) SWIG_fail;
7251 }
7252 {
7253 arg3 = (int)(SWIG_As_int(obj2));
7254 if (SWIG_arg_fail(3)) SWIG_fail;
7255 }
7256 {
7257 arg4 = (long)(SWIG_As_long(obj3));
7258 if (SWIG_arg_fail(4)) SWIG_fail;
7259 }
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7263
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 Py_INCREF(Py_None); resultobj = Py_None;
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj;
7276 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7277 int arg2 ;
7278 int arg3 ;
7279 double arg4 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 PyObject * obj2 = 0 ;
7283 PyObject * obj3 = 0 ;
7284 char *kwnames[] = {
7285 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7286 };
7287
7288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7290 if (SWIG_arg_fail(1)) SWIG_fail;
7291 {
7292 arg2 = (int)(SWIG_As_int(obj1));
7293 if (SWIG_arg_fail(2)) SWIG_fail;
7294 }
7295 {
7296 arg3 = (int)(SWIG_As_int(obj2));
7297 if (SWIG_arg_fail(3)) SWIG_fail;
7298 }
7299 {
7300 arg4 = (double)(SWIG_As_double(obj3));
7301 if (SWIG_arg_fail(4)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7306
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 Py_INCREF(Py_None); resultobj = Py_None;
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7320 int arg2 ;
7321 int arg3 ;
7322 bool arg4 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 PyObject * obj2 = 0 ;
7326 PyObject * obj3 = 0 ;
7327 char *kwnames[] = {
7328 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7329 };
7330
7331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7333 if (SWIG_arg_fail(1)) SWIG_fail;
7334 {
7335 arg2 = (int)(SWIG_As_int(obj1));
7336 if (SWIG_arg_fail(2)) SWIG_fail;
7337 }
7338 {
7339 arg3 = (int)(SWIG_As_int(obj2));
7340 if (SWIG_arg_fail(3)) SWIG_fail;
7341 }
7342 {
7343 arg4 = (bool)(SWIG_As_bool(obj3));
7344 if (SWIG_arg_fail(4)) SWIG_fail;
7345 }
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7349
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 Py_INCREF(Py_None); resultobj = Py_None;
7354 return resultobj;
7355 fail:
7356 return NULL;
7357 }
7358
7359
7360 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7361 PyObject *resultobj;
7362 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7363 PyObject * obj0 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 PyThreadState* __tstate = wxPyBeginAllowThreads();
7373 (arg1)->Clear();
7374
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 Py_INCREF(Py_None); resultobj = Py_None;
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj;
7387 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7388 size_t arg2 = (size_t) 0 ;
7389 size_t arg3 = (size_t) 1 ;
7390 bool result;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 PyObject * obj2 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 if (obj1) {
7402 {
7403 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7404 if (SWIG_arg_fail(2)) SWIG_fail;
7405 }
7406 }
7407 if (obj2) {
7408 {
7409 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7410 if (SWIG_arg_fail(3)) SWIG_fail;
7411 }
7412 }
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (bool)(arg1)->InsertRows(arg2,arg3);
7416
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 {
7421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7422 }
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7432 size_t arg2 = (size_t) 1 ;
7433 bool result;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char *kwnames[] = {
7437 (char *) "self",(char *) "numRows", NULL
7438 };
7439
7440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7442 if (SWIG_arg_fail(1)) SWIG_fail;
7443 if (obj1) {
7444 {
7445 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->AppendRows(arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7468 size_t arg2 = (size_t) 0 ;
7469 size_t arg3 = (size_t) 1 ;
7470 bool result;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 PyObject * obj2 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 if (obj1) {
7482 {
7483 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7484 if (SWIG_arg_fail(2)) SWIG_fail;
7485 }
7486 }
7487 if (obj2) {
7488 {
7489 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7490 if (SWIG_arg_fail(3)) SWIG_fail;
7491 }
7492 }
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7496
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7502 }
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj;
7511 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7512 size_t arg2 = (size_t) 0 ;
7513 size_t arg3 = (size_t) 1 ;
7514 bool result;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 PyObject * obj2 = 0 ;
7518 char *kwnames[] = {
7519 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7520 };
7521
7522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(1)) SWIG_fail;
7525 if (obj1) {
7526 {
7527 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7528 if (SWIG_arg_fail(2)) SWIG_fail;
7529 }
7530 }
7531 if (obj2) {
7532 {
7533 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7534 if (SWIG_arg_fail(3)) SWIG_fail;
7535 }
7536 }
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 result = (bool)(arg1)->InsertCols(arg2,arg3);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 {
7545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj;
7555 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7556 size_t arg2 = (size_t) 1 ;
7557 bool result;
7558 PyObject * obj0 = 0 ;
7559 PyObject * obj1 = 0 ;
7560 char *kwnames[] = {
7561 (char *) "self",(char *) "numCols", NULL
7562 };
7563
7564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7566 if (SWIG_arg_fail(1)) SWIG_fail;
7567 if (obj1) {
7568 {
7569 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7570 if (SWIG_arg_fail(2)) SWIG_fail;
7571 }
7572 }
7573 {
7574 PyThreadState* __tstate = wxPyBeginAllowThreads();
7575 result = (bool)(arg1)->AppendCols(arg2);
7576
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 {
7581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7592 size_t arg2 = (size_t) 0 ;
7593 size_t arg3 = (size_t) 1 ;
7594 bool result;
7595 PyObject * obj0 = 0 ;
7596 PyObject * obj1 = 0 ;
7597 PyObject * obj2 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 if (obj1) {
7606 {
7607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7608 if (SWIG_arg_fail(2)) SWIG_fail;
7609 }
7610 }
7611 if (obj2) {
7612 {
7613 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
7614 if (SWIG_arg_fail(3)) SWIG_fail;
7615 }
7616 }
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7626 }
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7636 int arg2 ;
7637 wxString result;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self",(char *) "row", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 arg2 = (int)(SWIG_As_int(obj1));
7649 if (SWIG_arg_fail(2)) SWIG_fail;
7650 }
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (arg1)->GetRowLabelValue(arg2);
7654
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 {
7659 #if wxUSE_UNICODE
7660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7661 #else
7662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7663 #endif
7664 }
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7674 int arg2 ;
7675 wxString result;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char *kwnames[] = {
7679 (char *) "self",(char *) "col", NULL
7680 };
7681
7682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7684 if (SWIG_arg_fail(1)) SWIG_fail;
7685 {
7686 arg2 = (int)(SWIG_As_int(obj1));
7687 if (SWIG_arg_fail(2)) SWIG_fail;
7688 }
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (arg1)->GetColLabelValue(arg2);
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 #if wxUSE_UNICODE
7698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7699 #else
7700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7701 #endif
7702 }
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj;
7711 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7712 int arg2 ;
7713 wxString *arg3 = 0 ;
7714 bool temp3 = false ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 PyObject * obj2 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self",(char *) "row",(char *) "value", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7724 if (SWIG_arg_fail(1)) SWIG_fail;
7725 {
7726 arg2 = (int)(SWIG_As_int(obj1));
7727 if (SWIG_arg_fail(2)) SWIG_fail;
7728 }
7729 {
7730 arg3 = wxString_in_helper(obj2);
7731 if (arg3 == NULL) SWIG_fail;
7732 temp3 = true;
7733 }
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 Py_INCREF(Py_None); resultobj = Py_None;
7742 {
7743 if (temp3)
7744 delete arg3;
7745 }
7746 return resultobj;
7747 fail:
7748 {
7749 if (temp3)
7750 delete arg3;
7751 }
7752 return NULL;
7753 }
7754
7755
7756 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj;
7758 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7759 int arg2 ;
7760 wxString *arg3 = 0 ;
7761 bool temp3 = false ;
7762 PyObject * obj0 = 0 ;
7763 PyObject * obj1 = 0 ;
7764 PyObject * obj2 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self",(char *) "col",(char *) "value", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 arg2 = (int)(SWIG_As_int(obj1));
7774 if (SWIG_arg_fail(2)) SWIG_fail;
7775 }
7776 {
7777 arg3 = wxString_in_helper(obj2);
7778 if (arg3 == NULL) SWIG_fail;
7779 temp3 = true;
7780 }
7781 {
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
7784
7785 wxPyEndAllowThreads(__tstate);
7786 if (PyErr_Occurred()) SWIG_fail;
7787 }
7788 Py_INCREF(Py_None); resultobj = Py_None;
7789 {
7790 if (temp3)
7791 delete arg3;
7792 }
7793 return resultobj;
7794 fail:
7795 {
7796 if (temp3)
7797 delete arg3;
7798 }
7799 return NULL;
7800 }
7801
7802
7803 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj;
7805 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7806 bool result;
7807 PyObject * obj0 = 0 ;
7808 char *kwnames[] = {
7809 (char *) "self", NULL
7810 };
7811
7812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
7813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7814 if (SWIG_arg_fail(1)) SWIG_fail;
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)(arg1)->CanHaveAttributes();
7818
7819 wxPyEndAllowThreads(__tstate);
7820 if (PyErr_Occurred()) SWIG_fail;
7821 }
7822 {
7823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7824 }
7825 return resultobj;
7826 fail:
7827 return NULL;
7828 }
7829
7830
7831 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7832 PyObject *resultobj;
7833 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7834 int arg2 ;
7835 int arg3 ;
7836 wxGridCellAttr::wxAttrKind arg4 ;
7837 wxGridCellAttr *result;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 PyObject * obj2 = 0 ;
7841 PyObject * obj3 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 arg2 = (int)(SWIG_As_int(obj1));
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 }
7853 {
7854 arg3 = (int)(SWIG_As_int(obj2));
7855 if (SWIG_arg_fail(3)) SWIG_fail;
7856 }
7857 {
7858 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
7859 if (SWIG_arg_fail(4)) SWIG_fail;
7860 }
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
7864
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 {
7869 resultobj = wxPyMake_wxGridCellAttr(result, 0);
7870 }
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj;
7879 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7880 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7881 int arg3 ;
7882 int arg4 ;
7883 PyObject * obj0 = 0 ;
7884 PyObject * obj1 = 0 ;
7885 PyObject * obj2 = 0 ;
7886 PyObject * obj3 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(2)) SWIG_fail;
7896 {
7897 arg3 = (int)(SWIG_As_int(obj2));
7898 if (SWIG_arg_fail(3)) SWIG_fail;
7899 }
7900 {
7901 arg4 = (int)(SWIG_As_int(obj3));
7902 if (SWIG_arg_fail(4)) SWIG_fail;
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 (arg1)->SetAttr(arg2,arg3,arg4);
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 Py_INCREF(Py_None); resultobj = Py_None;
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7919 PyObject *resultobj;
7920 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7921 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7922 int arg3 ;
7923 PyObject * obj0 = 0 ;
7924 PyObject * obj1 = 0 ;
7925 PyObject * obj2 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self",(char *) "attr",(char *) "row", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(2)) SWIG_fail;
7935 {
7936 arg3 = (int)(SWIG_As_int(obj2));
7937 if (SWIG_arg_fail(3)) SWIG_fail;
7938 }
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 (arg1)->SetRowAttr(arg2,arg3);
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 Py_INCREF(Py_None); resultobj = Py_None;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj;
7955 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7956 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7957 int arg3 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 PyObject * obj2 = 0 ;
7961 char *kwnames[] = {
7962 (char *) "self",(char *) "attr",(char *) "col", NULL
7963 };
7964
7965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
7966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7967 if (SWIG_arg_fail(1)) SWIG_fail;
7968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 {
7971 arg3 = (int)(SWIG_As_int(obj2));
7972 if (SWIG_arg_fail(3)) SWIG_fail;
7973 }
7974 {
7975 PyThreadState* __tstate = wxPyBeginAllowThreads();
7976 (arg1)->SetColAttr(arg2,arg3);
7977
7978 wxPyEndAllowThreads(__tstate);
7979 if (PyErr_Occurred()) SWIG_fail;
7980 }
7981 Py_INCREF(Py_None); resultobj = Py_None;
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
7989 PyObject *obj;
7990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7991 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
7992 Py_INCREF(obj);
7993 return Py_BuildValue((char *)"");
7994 }
7995 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxPyGridTableBase *result;
7998 char *kwnames[] = {
7999 NULL
8000 };
8001
8002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8020 PyObject *arg2 = (PyObject *) 0 ;
8021 PyObject *arg3 = (PyObject *) 0 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 PyObject * obj2 = 0 ;
8025 char *kwnames[] = {
8026 (char *) "self",(char *) "self",(char *) "_class", NULL
8027 };
8028
8029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 arg2 = obj1;
8033 arg3 = obj2;
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 (arg1)->_setCallbackInfo(arg2,arg3);
8037
8038 wxPyEndAllowThreads(__tstate);
8039 if (PyErr_Occurred()) SWIG_fail;
8040 }
8041 Py_INCREF(Py_None); resultobj = Py_None;
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj;
8050 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8051 PyObject * obj0 = 0 ;
8052 char *kwnames[] = {
8053 (char *) "self", NULL
8054 };
8055
8056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8058 if (SWIG_arg_fail(1)) SWIG_fail;
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 wxPyGridTableBase_Destroy(arg1);
8062
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 Py_INCREF(Py_None); resultobj = Py_None;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 static PyObject *_wrap_PyGridTableBase_base_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj;
8075 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8076 int arg2 ;
8077 int arg3 ;
8078 wxString result;
8079 PyObject * obj0 = 0 ;
8080 PyObject * obj1 = 0 ;
8081 PyObject * obj2 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "self",(char *) "row",(char *) "col", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(1)) SWIG_fail;
8089 {
8090 arg2 = (int)(SWIG_As_int(obj1));
8091 if (SWIG_arg_fail(2)) SWIG_fail;
8092 }
8093 {
8094 arg3 = (int)(SWIG_As_int(obj2));
8095 if (SWIG_arg_fail(3)) SWIG_fail;
8096 }
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (arg1)->base_GetTypeName(arg2,arg3);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 {
8105 #if wxUSE_UNICODE
8106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8107 #else
8108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8109 #endif
8110 }
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 static PyObject *_wrap_PyGridTableBase_base_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj;
8119 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8120 int arg2 ;
8121 int arg3 ;
8122 wxString *arg4 = 0 ;
8123 bool result;
8124 bool temp4 = false ;
8125 PyObject * obj0 = 0 ;
8126 PyObject * obj1 = 0 ;
8127 PyObject * obj2 = 0 ;
8128 PyObject * obj3 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 arg2 = (int)(SWIG_As_int(obj1));
8138 if (SWIG_arg_fail(2)) SWIG_fail;
8139 }
8140 {
8141 arg3 = (int)(SWIG_As_int(obj2));
8142 if (SWIG_arg_fail(3)) SWIG_fail;
8143 }
8144 {
8145 arg4 = wxString_in_helper(obj3);
8146 if (arg4 == NULL) SWIG_fail;
8147 temp4 = true;
8148 }
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (bool)(arg1)->base_CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8158 }
8159 {
8160 if (temp4)
8161 delete arg4;
8162 }
8163 return resultobj;
8164 fail:
8165 {
8166 if (temp4)
8167 delete arg4;
8168 }
8169 return NULL;
8170 }
8171
8172
8173 static PyObject *_wrap_PyGridTableBase_base_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj;
8175 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8176 int arg2 ;
8177 int arg3 ;
8178 wxString *arg4 = 0 ;
8179 bool result;
8180 bool temp4 = false ;
8181 PyObject * obj0 = 0 ;
8182 PyObject * obj1 = 0 ;
8183 PyObject * obj2 = 0 ;
8184 PyObject * obj3 = 0 ;
8185 char *kwnames[] = {
8186 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8187 };
8188
8189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8191 if (SWIG_arg_fail(1)) SWIG_fail;
8192 {
8193 arg2 = (int)(SWIG_As_int(obj1));
8194 if (SWIG_arg_fail(2)) SWIG_fail;
8195 }
8196 {
8197 arg3 = (int)(SWIG_As_int(obj2));
8198 if (SWIG_arg_fail(3)) SWIG_fail;
8199 }
8200 {
8201 arg4 = wxString_in_helper(obj3);
8202 if (arg4 == NULL) SWIG_fail;
8203 temp4 = true;
8204 }
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (bool)(arg1)->base_CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 {
8213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8214 }
8215 {
8216 if (temp4)
8217 delete arg4;
8218 }
8219 return resultobj;
8220 fail:
8221 {
8222 if (temp4)
8223 delete arg4;
8224 }
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_PyGridTableBase_base_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8232 PyObject * obj0 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_Clear",kwnames,&obj0)) goto fail;
8238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8239 if (SWIG_arg_fail(1)) SWIG_fail;
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 (arg1)->base_Clear();
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 Py_INCREF(Py_None); resultobj = Py_None;
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_PyGridTableBase_base_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj;
8256 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8257 size_t arg2 = (size_t) 0 ;
8258 size_t arg3 = (size_t) 1 ;
8259 bool result;
8260 PyObject * obj0 = 0 ;
8261 PyObject * obj1 = 0 ;
8262 PyObject * obj2 = 0 ;
8263 char *kwnames[] = {
8264 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8265 };
8266
8267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8269 if (SWIG_arg_fail(1)) SWIG_fail;
8270 if (obj1) {
8271 {
8272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8273 if (SWIG_arg_fail(2)) SWIG_fail;
8274 }
8275 }
8276 if (obj2) {
8277 {
8278 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8279 if (SWIG_arg_fail(3)) SWIG_fail;
8280 }
8281 }
8282 {
8283 PyThreadState* __tstate = wxPyBeginAllowThreads();
8284 result = (bool)(arg1)->base_InsertRows(arg2,arg3);
8285
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 {
8290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8291 }
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 static PyObject *_wrap_PyGridTableBase_base_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj;
8300 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8301 size_t arg2 = (size_t) 1 ;
8302 bool result;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 char *kwnames[] = {
8306 (char *) "self",(char *) "numRows", NULL
8307 };
8308
8309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(1)) SWIG_fail;
8312 if (obj1) {
8313 {
8314 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 }
8317 }
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 result = (bool)(arg1)->base_AppendRows(arg2);
8321
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 {
8326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_PyGridTableBase_base_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8337 size_t arg2 = (size_t) 0 ;
8338 size_t arg3 = (size_t) 1 ;
8339 bool result;
8340 PyObject * obj0 = 0 ;
8341 PyObject * obj1 = 0 ;
8342 PyObject * obj2 = 0 ;
8343 char *kwnames[] = {
8344 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8345 };
8346
8347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8349 if (SWIG_arg_fail(1)) SWIG_fail;
8350 if (obj1) {
8351 {
8352 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8353 if (SWIG_arg_fail(2)) SWIG_fail;
8354 }
8355 }
8356 if (obj2) {
8357 {
8358 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8359 if (SWIG_arg_fail(3)) SWIG_fail;
8360 }
8361 }
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (bool)(arg1)->base_DeleteRows(arg2,arg3);
8365
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 {
8370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8371 }
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_PyGridTableBase_base_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8381 size_t arg2 = (size_t) 0 ;
8382 size_t arg3 = (size_t) 1 ;
8383 bool result;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 if (obj1) {
8395 {
8396 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8397 if (SWIG_arg_fail(2)) SWIG_fail;
8398 }
8399 }
8400 if (obj2) {
8401 {
8402 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8403 if (SWIG_arg_fail(3)) SWIG_fail;
8404 }
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (bool)(arg1)->base_InsertCols(arg2,arg3);
8409
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 {
8414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8415 }
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 static PyObject *_wrap_PyGridTableBase_base_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj;
8424 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8425 size_t arg2 = (size_t) 1 ;
8426 bool result;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self",(char *) "numCols", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 if (obj1) {
8437 {
8438 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8439 if (SWIG_arg_fail(2)) SWIG_fail;
8440 }
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (bool)(arg1)->base_AppendCols(arg2);
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 {
8450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8451 }
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_PyGridTableBase_base_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj;
8460 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8461 size_t arg2 = (size_t) 0 ;
8462 size_t arg3 = (size_t) 1 ;
8463 bool result;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 PyObject * obj2 = 0 ;
8467 char *kwnames[] = {
8468 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8469 };
8470
8471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8473 if (SWIG_arg_fail(1)) SWIG_fail;
8474 if (obj1) {
8475 {
8476 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8477 if (SWIG_arg_fail(2)) SWIG_fail;
8478 }
8479 }
8480 if (obj2) {
8481 {
8482 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
8483 if (SWIG_arg_fail(3)) SWIG_fail;
8484 }
8485 }
8486 {
8487 PyThreadState* __tstate = wxPyBeginAllowThreads();
8488 result = (bool)(arg1)->base_DeleteCols(arg2,arg3);
8489
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 {
8494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_PyGridTableBase_base_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8505 int arg2 ;
8506 wxString result;
8507 PyObject * obj0 = 0 ;
8508 PyObject * obj1 = 0 ;
8509 char *kwnames[] = {
8510 (char *) "self",(char *) "row", NULL
8511 };
8512
8513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8515 if (SWIG_arg_fail(1)) SWIG_fail;
8516 {
8517 arg2 = (int)(SWIG_As_int(obj1));
8518 if (SWIG_arg_fail(2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 result = (arg1)->base_GetRowLabelValue(arg2);
8523
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 #if wxUSE_UNICODE
8529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8530 #else
8531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8532 #endif
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_PyGridTableBase_base_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8543 int arg2 ;
8544 wxString result;
8545 PyObject * obj0 = 0 ;
8546 PyObject * obj1 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self",(char *) "col", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 arg2 = (int)(SWIG_As_int(obj1));
8556 if (SWIG_arg_fail(2)) SWIG_fail;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (arg1)->base_GetColLabelValue(arg2);
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 #if wxUSE_UNICODE
8567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8568 #else
8569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8570 #endif
8571 }
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_PyGridTableBase_base_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8581 int arg2 ;
8582 wxString *arg3 = 0 ;
8583 bool temp3 = false ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 PyObject * obj2 = 0 ;
8587 char *kwnames[] = {
8588 (char *) "self",(char *) "row",(char *) "value", NULL
8589 };
8590
8591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8593 if (SWIG_arg_fail(1)) SWIG_fail;
8594 {
8595 arg2 = (int)(SWIG_As_int(obj1));
8596 if (SWIG_arg_fail(2)) SWIG_fail;
8597 }
8598 {
8599 arg3 = wxString_in_helper(obj2);
8600 if (arg3 == NULL) SWIG_fail;
8601 temp3 = true;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 (arg1)->base_SetRowLabelValue(arg2,(wxString const &)*arg3);
8606
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 Py_INCREF(Py_None); resultobj = Py_None;
8611 {
8612 if (temp3)
8613 delete arg3;
8614 }
8615 return resultobj;
8616 fail:
8617 {
8618 if (temp3)
8619 delete arg3;
8620 }
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_PyGridTableBase_base_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8628 int arg2 ;
8629 wxString *arg3 = 0 ;
8630 bool temp3 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 PyObject * obj2 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "col",(char *) "value", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = (int)(SWIG_As_int(obj1));
8643 if (SWIG_arg_fail(2)) SWIG_fail;
8644 }
8645 {
8646 arg3 = wxString_in_helper(obj2);
8647 if (arg3 == NULL) SWIG_fail;
8648 temp3 = true;
8649 }
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 (arg1)->base_SetColLabelValue(arg2,(wxString const &)*arg3);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 Py_INCREF(Py_None); resultobj = Py_None;
8658 {
8659 if (temp3)
8660 delete arg3;
8661 }
8662 return resultobj;
8663 fail:
8664 {
8665 if (temp3)
8666 delete arg3;
8667 }
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_PyGridTableBase_base_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj;
8674 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8675 bool result;
8676 PyObject * obj0 = 0 ;
8677 char *kwnames[] = {
8678 (char *) "self", NULL
8679 };
8680
8681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_CanHaveAttributes",kwnames,&obj0)) goto fail;
8682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8683 if (SWIG_arg_fail(1)) SWIG_fail;
8684 {
8685 PyThreadState* __tstate = wxPyBeginAllowThreads();
8686 result = (bool)(arg1)->base_CanHaveAttributes();
8687
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 {
8692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8693 }
8694 return resultobj;
8695 fail:
8696 return NULL;
8697 }
8698
8699
8700 static PyObject *_wrap_PyGridTableBase_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8701 PyObject *resultobj;
8702 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8703 int arg2 ;
8704 int arg3 ;
8705 wxGridCellAttr::wxAttrKind arg4 ;
8706 wxGridCellAttr *result;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 PyObject * obj2 = 0 ;
8710 PyObject * obj3 = 0 ;
8711 char *kwnames[] = {
8712 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 {
8719 arg2 = (int)(SWIG_As_int(obj1));
8720 if (SWIG_arg_fail(2)) SWIG_fail;
8721 }
8722 {
8723 arg3 = (int)(SWIG_As_int(obj2));
8724 if (SWIG_arg_fail(3)) SWIG_fail;
8725 }
8726 {
8727 arg4 = (wxGridCellAttr::wxAttrKind)(SWIG_As_int(obj3));
8728 if (SWIG_arg_fail(4)) SWIG_fail;
8729 }
8730 {
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,(wxGridCellAttr::wxAttrKind )arg4);
8733
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 {
8738 resultobj = wxPyMake_wxGridCellAttr(result, 0);
8739 }
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 static PyObject *_wrap_PyGridTableBase_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj;
8748 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8749 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8750 int arg3 ;
8751 int arg4 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 PyObject * obj2 = 0 ;
8755 PyObject * obj3 = 0 ;
8756 char *kwnames[] = {
8757 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8764 if (SWIG_arg_fail(2)) SWIG_fail;
8765 {
8766 arg3 = (int)(SWIG_As_int(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 {
8770 arg4 = (int)(SWIG_As_int(obj3));
8771 if (SWIG_arg_fail(4)) SWIG_fail;
8772 }
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 (arg1)->base_SetAttr(arg2,arg3,arg4);
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 Py_INCREF(Py_None); resultobj = Py_None;
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 static PyObject *_wrap_PyGridTableBase_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8788 PyObject *resultobj;
8789 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8790 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8791 int arg3 ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 PyObject * obj2 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self",(char *) "attr",(char *) "row", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8803 if (SWIG_arg_fail(2)) SWIG_fail;
8804 {
8805 arg3 = (int)(SWIG_As_int(obj2));
8806 if (SWIG_arg_fail(3)) SWIG_fail;
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 (arg1)->base_SetRowAttr(arg2,arg3);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 Py_INCREF(Py_None); resultobj = Py_None;
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 static PyObject *_wrap_PyGridTableBase_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8823 PyObject *resultobj;
8824 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8825 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8826 int arg3 ;
8827 PyObject * obj0 = 0 ;
8828 PyObject * obj1 = 0 ;
8829 PyObject * obj2 = 0 ;
8830 char *kwnames[] = {
8831 (char *) "self",(char *) "attr",(char *) "col", NULL
8832 };
8833
8834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8836 if (SWIG_arg_fail(1)) SWIG_fail;
8837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(2)) SWIG_fail;
8839 {
8840 arg3 = (int)(SWIG_As_int(obj2));
8841 if (SWIG_arg_fail(3)) SWIG_fail;
8842 }
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 (arg1)->base_SetColAttr(arg2,arg3);
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 Py_INCREF(Py_None); resultobj = Py_None;
8851 return resultobj;
8852 fail:
8853 return NULL;
8854 }
8855
8856
8857 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
8858 PyObject *obj;
8859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8860 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
8861 Py_INCREF(obj);
8862 return Py_BuildValue((char *)"");
8863 }
8864 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
8865 PyObject *resultobj;
8866 int arg1 = (int) 0 ;
8867 int arg2 = (int) 0 ;
8868 wxGridStringTable *result;
8869 PyObject * obj0 = 0 ;
8870 PyObject * obj1 = 0 ;
8871 char *kwnames[] = {
8872 (char *) "numRows",(char *) "numCols", NULL
8873 };
8874
8875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
8876 if (obj0) {
8877 {
8878 arg1 = (int)(SWIG_As_int(obj0));
8879 if (SWIG_arg_fail(1)) SWIG_fail;
8880 }
8881 }
8882 if (obj1) {
8883 {
8884 arg2 = (int)(SWIG_As_int(obj1));
8885 if (SWIG_arg_fail(2)) SWIG_fail;
8886 }
8887 }
8888 {
8889 PyThreadState* __tstate = wxPyBeginAllowThreads();
8890 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
8891
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
8903 PyObject *obj;
8904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8905 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
8906 Py_INCREF(obj);
8907 return Py_BuildValue((char *)"");
8908 }
8909 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8910 PyObject *resultobj;
8911 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8912 int arg2 ;
8913 int arg3 = (int) -1 ;
8914 int arg4 = (int) -1 ;
8915 wxGridTableMessage *result;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 PyObject * obj3 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 arg2 = (int)(SWIG_As_int(obj1));
8929 if (SWIG_arg_fail(2)) SWIG_fail;
8930 }
8931 if (obj2) {
8932 {
8933 arg3 = (int)(SWIG_As_int(obj2));
8934 if (SWIG_arg_fail(3)) SWIG_fail;
8935 }
8936 }
8937 if (obj3) {
8938 {
8939 arg4 = (int)(SWIG_As_int(obj3));
8940 if (SWIG_arg_fail(4)) SWIG_fail;
8941 }
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
8946
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj;
8959 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8960 PyObject * obj0 = 0 ;
8961 char *kwnames[] = {
8962 (char *) "self", NULL
8963 };
8964
8965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
8966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8967 if (SWIG_arg_fail(1)) SWIG_fail;
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 delete arg1;
8971
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 Py_INCREF(Py_None); resultobj = Py_None;
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
8985 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
8986 PyObject * obj0 = 0 ;
8987 PyObject * obj1 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "table", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 (arg1)->SetTableObject(arg2);
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 Py_INCREF(Py_None); resultobj = Py_None;
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9014 wxGridTableBase *result;
9015 PyObject * obj0 = 0 ;
9016 char *kwnames[] = {
9017 (char *) "self", NULL
9018 };
9019
9020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9022 if (SWIG_arg_fail(1)) SWIG_fail;
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 {
9031 resultobj = wxPyMake_wxGridTableBase(result, 0);
9032 }
9033 return resultobj;
9034 fail:
9035 return NULL;
9036 }
9037
9038
9039 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj;
9041 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9042 int arg2 ;
9043 PyObject * obj0 = 0 ;
9044 PyObject * obj1 = 0 ;
9045 char *kwnames[] = {
9046 (char *) "self",(char *) "id", NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9051 if (SWIG_arg_fail(1)) SWIG_fail;
9052 {
9053 arg2 = (int)(SWIG_As_int(obj1));
9054 if (SWIG_arg_fail(2)) SWIG_fail;
9055 }
9056 {
9057 PyThreadState* __tstate = wxPyBeginAllowThreads();
9058 (arg1)->SetId(arg2);
9059
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 Py_INCREF(Py_None); resultobj = Py_None;
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj;
9072 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9073 int result;
9074 PyObject * obj0 = 0 ;
9075 char *kwnames[] = {
9076 (char *) "self", NULL
9077 };
9078
9079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9081 if (SWIG_arg_fail(1)) SWIG_fail;
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 result = (int)(arg1)->GetId();
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 {
9090 resultobj = SWIG_From_int((int)(result));
9091 }
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9101 int arg2 ;
9102 PyObject * obj0 = 0 ;
9103 PyObject * obj1 = 0 ;
9104 char *kwnames[] = {
9105 (char *) "self",(char *) "comInt1", NULL
9106 };
9107
9108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9110 if (SWIG_arg_fail(1)) SWIG_fail;
9111 {
9112 arg2 = (int)(SWIG_As_int(obj1));
9113 if (SWIG_arg_fail(2)) SWIG_fail;
9114 }
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 (arg1)->SetCommandInt(arg2);
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 Py_INCREF(Py_None); resultobj = Py_None;
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj;
9131 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9132 int result;
9133 PyObject * obj0 = 0 ;
9134 char *kwnames[] = {
9135 (char *) "self", NULL
9136 };
9137
9138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9140 if (SWIG_arg_fail(1)) SWIG_fail;
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 result = (int)(arg1)->GetCommandInt();
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 {
9149 resultobj = SWIG_From_int((int)(result));
9150 }
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9160 int arg2 ;
9161 PyObject * obj0 = 0 ;
9162 PyObject * obj1 = 0 ;
9163 char *kwnames[] = {
9164 (char *) "self",(char *) "comInt2", NULL
9165 };
9166
9167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 {
9171 arg2 = (int)(SWIG_As_int(obj1));
9172 if (SWIG_arg_fail(2)) SWIG_fail;
9173 }
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 (arg1)->SetCommandInt2(arg2);
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 Py_INCREF(Py_None); resultobj = Py_None;
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj;
9190 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9191 int result;
9192 PyObject * obj0 = 0 ;
9193 char *kwnames[] = {
9194 (char *) "self", NULL
9195 };
9196
9197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9199 if (SWIG_arg_fail(1)) SWIG_fail;
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (int)(arg1)->GetCommandInt2();
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 {
9208 resultobj = SWIG_From_int((int)(result));
9209 }
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9217 PyObject *obj;
9218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9219 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9220 Py_INCREF(obj);
9221 return Py_BuildValue((char *)"");
9222 }
9223 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 int arg1 = (int) -1 ;
9226 int arg2 = (int) -1 ;
9227 wxGridCellCoords *result;
9228 PyObject * obj0 = 0 ;
9229 PyObject * obj1 = 0 ;
9230 char *kwnames[] = {
9231 (char *) "r",(char *) "c", NULL
9232 };
9233
9234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9235 if (obj0) {
9236 {
9237 arg1 = (int)(SWIG_As_int(obj0));
9238 if (SWIG_arg_fail(1)) SWIG_fail;
9239 }
9240 }
9241 if (obj1) {
9242 {
9243 arg2 = (int)(SWIG_As_int(obj1));
9244 if (SWIG_arg_fail(2)) SWIG_fail;
9245 }
9246 }
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9250
9251 wxPyEndAllowThreads(__tstate);
9252 if (PyErr_Occurred()) SWIG_fail;
9253 }
9254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj;
9263 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9264 PyObject * obj0 = 0 ;
9265 char *kwnames[] = {
9266 (char *) "self", NULL
9267 };
9268
9269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9271 if (SWIG_arg_fail(1)) SWIG_fail;
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 delete arg1;
9275
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 Py_INCREF(Py_None); resultobj = Py_None;
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj;
9288 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9289 int result;
9290 PyObject * obj0 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 {
9306 resultobj = SWIG_From_int((int)(result));
9307 }
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9317 int arg2 ;
9318 PyObject * obj0 = 0 ;
9319 PyObject * obj1 = 0 ;
9320 char *kwnames[] = {
9321 (char *) "self",(char *) "n", NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9326 if (SWIG_arg_fail(1)) SWIG_fail;
9327 {
9328 arg2 = (int)(SWIG_As_int(obj1));
9329 if (SWIG_arg_fail(2)) SWIG_fail;
9330 }
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 (arg1)->SetRow(arg2);
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 Py_INCREF(Py_None); resultobj = Py_None;
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9346 PyObject *resultobj;
9347 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9348 int result;
9349 PyObject * obj0 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 {
9365 resultobj = SWIG_From_int((int)(result));
9366 }
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj;
9375 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9376 int arg2 ;
9377 PyObject * obj0 = 0 ;
9378 PyObject * obj1 = 0 ;
9379 char *kwnames[] = {
9380 (char *) "self",(char *) "n", NULL
9381 };
9382
9383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9385 if (SWIG_arg_fail(1)) SWIG_fail;
9386 {
9387 arg2 = (int)(SWIG_As_int(obj1));
9388 if (SWIG_arg_fail(2)) SWIG_fail;
9389 }
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 (arg1)->SetCol(arg2);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 Py_INCREF(Py_None); resultobj = Py_None;
9398 return resultobj;
9399 fail:
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9407 int arg2 ;
9408 int arg3 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 PyObject * obj2 = 0 ;
9412 char *kwnames[] = {
9413 (char *) "self",(char *) "row",(char *) "col", NULL
9414 };
9415
9416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9418 if (SWIG_arg_fail(1)) SWIG_fail;
9419 {
9420 arg2 = (int)(SWIG_As_int(obj1));
9421 if (SWIG_arg_fail(2)) SWIG_fail;
9422 }
9423 {
9424 arg3 = (int)(SWIG_As_int(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 (arg1)->Set(arg2,arg3);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 Py_INCREF(Py_None); resultobj = Py_None;
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj;
9443 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9444 wxGridCellCoords *arg2 = 0 ;
9445 bool result;
9446 wxGridCellCoords temp2 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 char *kwnames[] = {
9450 (char *) "self",(char *) "other", NULL
9451 };
9452
9453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) goto fail;
9454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9455 if (SWIG_arg_fail(1)) SWIG_fail;
9456 {
9457 arg2 = &temp2;
9458 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 {
9468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9469 }
9470 return resultobj;
9471 fail:
9472 return NULL;
9473 }
9474
9475
9476 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9477 PyObject *resultobj;
9478 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9479 wxGridCellCoords *arg2 = 0 ;
9480 bool result;
9481 wxGridCellCoords temp2 ;
9482 PyObject * obj0 = 0 ;
9483 PyObject * obj1 = 0 ;
9484 char *kwnames[] = {
9485 (char *) "self",(char *) "other", NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9490 if (SWIG_arg_fail(1)) SWIG_fail;
9491 {
9492 arg2 = &temp2;
9493 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9494 }
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9498
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 {
9503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9504 }
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj;
9513 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9514 PyObject *result;
9515 PyObject * obj0 = 0 ;
9516 char *kwnames[] = {
9517 (char *) "self", NULL
9518 };
9519
9520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9522 if (SWIG_arg_fail(1)) SWIG_fail;
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (PyObject *)wxGridCellCoords_Get(arg1);
9526
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 resultobj = result;
9531 return resultobj;
9532 fail:
9533 return NULL;
9534 }
9535
9536
9537 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9538 PyObject *obj;
9539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9540 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9541 Py_INCREF(obj);
9542 return Py_BuildValue((char *)"");
9543 }
9544 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj;
9546 wxWindow *arg1 = (wxWindow *) 0 ;
9547 int arg2 = (int) -1 ;
9548 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9549 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9550 wxSize const &arg4_defvalue = wxDefaultSize ;
9551 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9552 long arg5 = (long) wxWANTS_CHARS ;
9553 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9554 wxString *arg6 = (wxString *) &arg6_defvalue ;
9555 wxGrid *result;
9556 wxPoint temp3 ;
9557 wxSize temp4 ;
9558 bool temp6 = false ;
9559 PyObject * obj0 = 0 ;
9560 PyObject * obj1 = 0 ;
9561 PyObject * obj2 = 0 ;
9562 PyObject * obj3 = 0 ;
9563 PyObject * obj4 = 0 ;
9564 PyObject * obj5 = 0 ;
9565 char *kwnames[] = {
9566 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9567 };
9568
9569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9571 if (SWIG_arg_fail(1)) SWIG_fail;
9572 if (obj1) {
9573 {
9574 arg2 = (int)(SWIG_As_int(obj1));
9575 if (SWIG_arg_fail(2)) SWIG_fail;
9576 }
9577 }
9578 if (obj2) {
9579 {
9580 arg3 = &temp3;
9581 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9582 }
9583 }
9584 if (obj3) {
9585 {
9586 arg4 = &temp4;
9587 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9588 }
9589 }
9590 if (obj4) {
9591 {
9592 arg5 = (long)(SWIG_As_long(obj4));
9593 if (SWIG_arg_fail(5)) SWIG_fail;
9594 }
9595 }
9596 if (obj5) {
9597 {
9598 arg6 = wxString_in_helper(obj5);
9599 if (arg6 == NULL) SWIG_fail;
9600 temp6 = true;
9601 }
9602 }
9603 {
9604 if (!wxPyCheckForApp()) SWIG_fail;
9605 PyThreadState* __tstate = wxPyBeginAllowThreads();
9606 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9607
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9612 {
9613 if (temp6)
9614 delete arg6;
9615 }
9616 return resultobj;
9617 fail:
9618 {
9619 if (temp6)
9620 delete arg6;
9621 }
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxGrid *result;
9629 char *kwnames[] = {
9630 NULL
9631 };
9632
9633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9634 {
9635 if (!wxPyCheckForApp()) SWIG_fail;
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 result = (wxGrid *)new wxGrid();
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxGrid *arg1 = (wxGrid *) 0 ;
9652 wxWindow *arg2 = (wxWindow *) 0 ;
9653 int arg3 = (int) -1 ;
9654 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9655 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9656 wxSize const &arg5_defvalue = wxDefaultSize ;
9657 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9658 long arg6 = (long) wxWANTS_CHARS ;
9659 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9660 wxString *arg7 = (wxString *) &arg7_defvalue ;
9661 bool result;
9662 wxPoint temp4 ;
9663 wxSize temp5 ;
9664 bool temp7 = false ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 PyObject * obj2 = 0 ;
9668 PyObject * obj3 = 0 ;
9669 PyObject * obj4 = 0 ;
9670 PyObject * obj5 = 0 ;
9671 PyObject * obj6 = 0 ;
9672 char *kwnames[] = {
9673 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9674 };
9675
9676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9678 if (SWIG_arg_fail(1)) SWIG_fail;
9679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9680 if (SWIG_arg_fail(2)) SWIG_fail;
9681 if (obj2) {
9682 {
9683 arg3 = (int)(SWIG_As_int(obj2));
9684 if (SWIG_arg_fail(3)) SWIG_fail;
9685 }
9686 }
9687 if (obj3) {
9688 {
9689 arg4 = &temp4;
9690 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9691 }
9692 }
9693 if (obj4) {
9694 {
9695 arg5 = &temp5;
9696 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9697 }
9698 }
9699 if (obj5) {
9700 {
9701 arg6 = (long)(SWIG_As_long(obj5));
9702 if (SWIG_arg_fail(6)) SWIG_fail;
9703 }
9704 }
9705 if (obj6) {
9706 {
9707 arg7 = wxString_in_helper(obj6);
9708 if (arg7 == NULL) SWIG_fail;
9709 temp7 = true;
9710 }
9711 }
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 {
9720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9721 }
9722 {
9723 if (temp7)
9724 delete arg7;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp7)
9730 delete arg7;
9731 }
9732 return NULL;
9733 }
9734
9735
9736 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj;
9738 wxGrid *arg1 = (wxGrid *) 0 ;
9739 int arg2 ;
9740 int arg3 ;
9741 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9742 bool result;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 PyObject * obj2 = 0 ;
9746 PyObject * obj3 = 0 ;
9747 char *kwnames[] = {
9748 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9749 };
9750
9751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9753 if (SWIG_arg_fail(1)) SWIG_fail;
9754 {
9755 arg2 = (int)(SWIG_As_int(obj1));
9756 if (SWIG_arg_fail(2)) SWIG_fail;
9757 }
9758 {
9759 arg3 = (int)(SWIG_As_int(obj2));
9760 if (SWIG_arg_fail(3)) SWIG_fail;
9761 }
9762 if (obj3) {
9763 {
9764 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9765 if (SWIG_arg_fail(4)) SWIG_fail;
9766 }
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj;
9786 wxGrid *arg1 = (wxGrid *) 0 ;
9787 WXGRIDSELECTIONMODES arg2 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self",(char *) "selmode", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 arg2 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj1));
9799 if (SWIG_arg_fail(2)) SWIG_fail;
9800 }
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 (arg1)->SetSelectionMode(arg2);
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 Py_INCREF(Py_None); resultobj = Py_None;
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj;
9817 wxGrid *arg1 = (wxGrid *) 0 ;
9818 WXGRIDSELECTIONMODES result;
9819 PyObject * obj0 = 0 ;
9820 char *kwnames[] = {
9821 (char *) "self", NULL
9822 };
9823
9824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
9825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9826 if (SWIG_arg_fail(1)) SWIG_fail;
9827 {
9828 PyThreadState* __tstate = wxPyBeginAllowThreads();
9829 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
9830
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 {
9835 resultobj = SWIG_From_int((int)(result));
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxGrid *arg1 = (wxGrid *) 0 ;
9846 int result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (int)(arg1)->GetNumberRows();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 {
9863 resultobj = SWIG_From_int((int)(result));
9864 }
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxGrid *arg1 = (wxGrid *) 0 ;
9874 int result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (int)(arg1)->GetNumberCols();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 resultobj = SWIG_From_int((int)(result));
9892 }
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxGrid *arg1 = (wxGrid *) 0 ;
9902 wxGridTableMessage *arg2 = 0 ;
9903 bool result;
9904 PyObject * obj0 = 0 ;
9905 PyObject * obj1 = 0 ;
9906 char *kwnames[] = {
9907 (char *) "self","arg2", NULL
9908 };
9909
9910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
9911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9912 if (SWIG_arg_fail(1)) SWIG_fail;
9913 {
9914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9915 if (SWIG_arg_fail(2)) SWIG_fail;
9916 if (arg2 == NULL) {
9917 SWIG_null_ref("wxGridTableMessage");
9918 }
9919 if (SWIG_arg_fail(2)) SWIG_fail;
9920 }
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (bool)(arg1)->ProcessTableMessage(*arg2);
9924
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 {
9929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9930 }
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxGrid *arg1 = (wxGrid *) 0 ;
9940 wxGridTableBase *result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "self", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
9947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
9952
9953 wxPyEndAllowThreads(__tstate);
9954 if (PyErr_Occurred()) SWIG_fail;
9955 }
9956 {
9957 resultobj = wxPyMake_wxGridTableBase(result, 0);
9958 }
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
9966 PyObject *resultobj;
9967 wxGrid *arg1 = (wxGrid *) 0 ;
9968 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9969 bool arg3 = (bool) false ;
9970 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9971 bool result;
9972 PyObject * obj0 = 0 ;
9973 PyObject * obj1 = 0 ;
9974 PyObject * obj2 = 0 ;
9975 PyObject * obj3 = 0 ;
9976 char *kwnames[] = {
9977 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
9978 };
9979
9980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9982 if (SWIG_arg_fail(1)) SWIG_fail;
9983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9984 if (SWIG_arg_fail(2)) SWIG_fail;
9985 if (obj2) {
9986 {
9987 arg3 = (bool)(SWIG_As_bool(obj2));
9988 if (SWIG_arg_fail(3)) SWIG_fail;
9989 }
9990 }
9991 if (obj3) {
9992 {
9993 arg4 = (WXGRIDSELECTIONMODES)(SWIG_As_int(obj3));
9994 if (SWIG_arg_fail(4)) SWIG_fail;
9995 }
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 return resultobj;
10008 fail:
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxGrid *arg1 = (wxGrid *) 0 ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "self", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10023 if (SWIG_arg_fail(1)) SWIG_fail;
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 (arg1)->ClearGrid();
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 Py_INCREF(Py_None); resultobj = Py_None;
10032 return resultobj;
10033 fail:
10034 return NULL;
10035 }
10036
10037
10038 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxGrid *arg1 = (wxGrid *) 0 ;
10041 int arg2 = (int) 0 ;
10042 int arg3 = (int) 1 ;
10043 bool arg4 = (bool) true ;
10044 bool result;
10045 PyObject * obj0 = 0 ;
10046 PyObject * obj1 = 0 ;
10047 PyObject * obj2 = 0 ;
10048 PyObject * obj3 = 0 ;
10049 char *kwnames[] = {
10050 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10051 };
10052
10053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10055 if (SWIG_arg_fail(1)) SWIG_fail;
10056 if (obj1) {
10057 {
10058 arg2 = (int)(SWIG_As_int(obj1));
10059 if (SWIG_arg_fail(2)) SWIG_fail;
10060 }
10061 }
10062 if (obj2) {
10063 {
10064 arg3 = (int)(SWIG_As_int(obj2));
10065 if (SWIG_arg_fail(3)) SWIG_fail;
10066 }
10067 }
10068 if (obj3) {
10069 {
10070 arg4 = (bool)(SWIG_As_bool(obj3));
10071 if (SWIG_arg_fail(4)) SWIG_fail;
10072 }
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 {
10082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10083 }
10084 return resultobj;
10085 fail:
10086 return NULL;
10087 }
10088
10089
10090 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10091 PyObject *resultobj;
10092 wxGrid *arg1 = (wxGrid *) 0 ;
10093 int arg2 = (int) 1 ;
10094 bool arg3 = (bool) true ;
10095 bool result;
10096 PyObject * obj0 = 0 ;
10097 PyObject * obj1 = 0 ;
10098 PyObject * obj2 = 0 ;
10099 char *kwnames[] = {
10100 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10101 };
10102
10103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10105 if (SWIG_arg_fail(1)) SWIG_fail;
10106 if (obj1) {
10107 {
10108 arg2 = (int)(SWIG_As_int(obj1));
10109 if (SWIG_arg_fail(2)) SWIG_fail;
10110 }
10111 }
10112 if (obj2) {
10113 {
10114 arg3 = (bool)(SWIG_As_bool(obj2));
10115 if (SWIG_arg_fail(3)) SWIG_fail;
10116 }
10117 }
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 result = (bool)(arg1)->AppendRows(arg2,arg3);
10121
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 {
10126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10127 }
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxGrid *arg1 = (wxGrid *) 0 ;
10137 int arg2 = (int) 0 ;
10138 int arg3 = (int) 1 ;
10139 bool arg4 = (bool) true ;
10140 bool result;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 PyObject * obj2 = 0 ;
10144 PyObject * obj3 = 0 ;
10145 char *kwnames[] = {
10146 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10147 };
10148
10149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10151 if (SWIG_arg_fail(1)) SWIG_fail;
10152 if (obj1) {
10153 {
10154 arg2 = (int)(SWIG_As_int(obj1));
10155 if (SWIG_arg_fail(2)) SWIG_fail;
10156 }
10157 }
10158 if (obj2) {
10159 {
10160 arg3 = (int)(SWIG_As_int(obj2));
10161 if (SWIG_arg_fail(3)) SWIG_fail;
10162 }
10163 }
10164 if (obj3) {
10165 {
10166 arg4 = (bool)(SWIG_As_bool(obj3));
10167 if (SWIG_arg_fail(4)) SWIG_fail;
10168 }
10169 }
10170 {
10171 PyThreadState* __tstate = wxPyBeginAllowThreads();
10172 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10173
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 {
10178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10179 }
10180 return resultobj;
10181 fail:
10182 return NULL;
10183 }
10184
10185
10186 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj;
10188 wxGrid *arg1 = (wxGrid *) 0 ;
10189 int arg2 = (int) 0 ;
10190 int arg3 = (int) 1 ;
10191 bool arg4 = (bool) true ;
10192 bool result;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 PyObject * obj2 = 0 ;
10196 PyObject * obj3 = 0 ;
10197 char *kwnames[] = {
10198 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10199 };
10200
10201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10203 if (SWIG_arg_fail(1)) SWIG_fail;
10204 if (obj1) {
10205 {
10206 arg2 = (int)(SWIG_As_int(obj1));
10207 if (SWIG_arg_fail(2)) SWIG_fail;
10208 }
10209 }
10210 if (obj2) {
10211 {
10212 arg3 = (int)(SWIG_As_int(obj2));
10213 if (SWIG_arg_fail(3)) SWIG_fail;
10214 }
10215 }
10216 if (obj3) {
10217 {
10218 arg4 = (bool)(SWIG_As_bool(obj3));
10219 if (SWIG_arg_fail(4)) SWIG_fail;
10220 }
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10225
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 {
10230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10231 }
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 wxGrid *arg1 = (wxGrid *) 0 ;
10241 int arg2 = (int) 1 ;
10242 bool arg3 = (bool) true ;
10243 bool result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10253 if (SWIG_arg_fail(1)) SWIG_fail;
10254 if (obj1) {
10255 {
10256 arg2 = (int)(SWIG_As_int(obj1));
10257 if (SWIG_arg_fail(2)) SWIG_fail;
10258 }
10259 }
10260 if (obj2) {
10261 {
10262 arg3 = (bool)(SWIG_As_bool(obj2));
10263 if (SWIG_arg_fail(3)) SWIG_fail;
10264 }
10265 }
10266 {
10267 PyThreadState* __tstate = wxPyBeginAllowThreads();
10268 result = (bool)(arg1)->AppendCols(arg2,arg3);
10269
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10275 }
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxGrid *arg1 = (wxGrid *) 0 ;
10285 int arg2 = (int) 0 ;
10286 int arg3 = (int) 1 ;
10287 bool arg4 = (bool) true ;
10288 bool result;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 PyObject * obj2 = 0 ;
10292 PyObject * obj3 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10295 };
10296
10297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10299 if (SWIG_arg_fail(1)) SWIG_fail;
10300 if (obj1) {
10301 {
10302 arg2 = (int)(SWIG_As_int(obj1));
10303 if (SWIG_arg_fail(2)) SWIG_fail;
10304 }
10305 }
10306 if (obj2) {
10307 {
10308 arg3 = (int)(SWIG_As_int(obj2));
10309 if (SWIG_arg_fail(3)) SWIG_fail;
10310 }
10311 }
10312 if (obj3) {
10313 {
10314 arg4 = (bool)(SWIG_As_bool(obj3));
10315 if (SWIG_arg_fail(4)) SWIG_fail;
10316 }
10317 }
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10321
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10327 }
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxGrid *arg1 = (wxGrid *) 0 ;
10337 wxDC *arg2 = 0 ;
10338 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 PyObject * obj2 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "self",(char *) "dc",(char *) "attr", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(1)) SWIG_fail;
10349 {
10350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10351 if (SWIG_arg_fail(2)) SWIG_fail;
10352 if (arg2 == NULL) {
10353 SWIG_null_ref("wxDC");
10354 }
10355 if (SWIG_arg_fail(2)) SWIG_fail;
10356 }
10357 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(3)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxGrid *arg1 = (wxGrid *) 0 ;
10376 wxDC *arg2 = 0 ;
10377 wxString *arg3 = 0 ;
10378 wxRect *arg4 = 0 ;
10379 int arg5 = (int) wxLEFT ;
10380 int arg6 = (int) wxTOP ;
10381 int arg7 = (int) wxHORIZONTAL ;
10382 bool temp3 = false ;
10383 wxRect temp4 ;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 PyObject * obj3 = 0 ;
10388 PyObject * obj4 = 0 ;
10389 PyObject * obj5 = 0 ;
10390 PyObject * obj6 = 0 ;
10391 char *kwnames[] = {
10392 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10393 };
10394
10395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10397 if (SWIG_arg_fail(1)) SWIG_fail;
10398 {
10399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10400 if (SWIG_arg_fail(2)) SWIG_fail;
10401 if (arg2 == NULL) {
10402 SWIG_null_ref("wxDC");
10403 }
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = wxString_in_helper(obj2);
10408 if (arg3 == NULL) SWIG_fail;
10409 temp3 = true;
10410 }
10411 {
10412 arg4 = &temp4;
10413 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10414 }
10415 if (obj4) {
10416 {
10417 arg5 = (int)(SWIG_As_int(obj4));
10418 if (SWIG_arg_fail(5)) SWIG_fail;
10419 }
10420 }
10421 if (obj5) {
10422 {
10423 arg6 = (int)(SWIG_As_int(obj5));
10424 if (SWIG_arg_fail(6)) SWIG_fail;
10425 }
10426 }
10427 if (obj6) {
10428 {
10429 arg7 = (int)(SWIG_As_int(obj6));
10430 if (SWIG_arg_fail(7)) SWIG_fail;
10431 }
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 Py_INCREF(Py_None); resultobj = Py_None;
10441 {
10442 if (temp3)
10443 delete arg3;
10444 }
10445 return resultobj;
10446 fail:
10447 {
10448 if (temp3)
10449 delete arg3;
10450 }
10451 return NULL;
10452 }
10453
10454
10455 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10456 PyObject *resultobj;
10457 wxGrid *arg1 = (wxGrid *) 0 ;
10458 wxDC *arg2 = 0 ;
10459 wxArrayString *arg3 = 0 ;
10460 long *arg4 = (long *) 0 ;
10461 long *arg5 = (long *) 0 ;
10462 bool temp3 = false ;
10463 long temp4 ;
10464 int res4 = 0 ;
10465 long temp5 ;
10466 int res5 = 0 ;
10467 PyObject * obj0 = 0 ;
10468 PyObject * obj1 = 0 ;
10469 PyObject * obj2 = 0 ;
10470 char *kwnames[] = {
10471 (char *) "self",(char *) "dc",(char *) "lines", NULL
10472 };
10473
10474 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10475 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10478 if (SWIG_arg_fail(1)) SWIG_fail;
10479 {
10480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10481 if (SWIG_arg_fail(2)) SWIG_fail;
10482 if (arg2 == NULL) {
10483 SWIG_null_ref("wxDC");
10484 }
10485 if (SWIG_arg_fail(2)) SWIG_fail;
10486 }
10487 {
10488 if (! PySequence_Check(obj2)) {
10489 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10490 SWIG_fail;
10491 }
10492 arg3 = new wxArrayString;
10493 temp3 = true;
10494 int i, len=PySequence_Length(obj2);
10495 for (i=0; i<len; i++) {
10496 PyObject* item = PySequence_GetItem(obj2, i);
10497 #if wxUSE_UNICODE
10498 PyObject* str = PyObject_Unicode(item);
10499 #else
10500 PyObject* str = PyObject_Str(item);
10501 #endif
10502 if (PyErr_Occurred()) SWIG_fail;
10503 arg3->Add(Py2wxString(str));
10504 Py_DECREF(item);
10505 Py_DECREF(str);
10506 }
10507 }
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 Py_INCREF(Py_None); resultobj = Py_None;
10516 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10517 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10518 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10519 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10520 {
10521 if (temp3) delete arg3;
10522 }
10523 return resultobj;
10524 fail:
10525 {
10526 if (temp3) delete arg3;
10527 }
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxGrid *arg1 = (wxGrid *) 0 ;
10535 PyObject * obj0 = 0 ;
10536 char *kwnames[] = {
10537 (char *) "self", NULL
10538 };
10539
10540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10542 if (SWIG_arg_fail(1)) SWIG_fail;
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 (arg1)->BeginBatch();
10546
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 Py_INCREF(Py_None); resultobj = Py_None;
10551 return resultobj;
10552 fail:
10553 return NULL;
10554 }
10555
10556
10557 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10558 PyObject *resultobj;
10559 wxGrid *arg1 = (wxGrid *) 0 ;
10560 PyObject * obj0 = 0 ;
10561 char *kwnames[] = {
10562 (char *) "self", NULL
10563 };
10564
10565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10567 if (SWIG_arg_fail(1)) SWIG_fail;
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 (arg1)->EndBatch();
10571
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 Py_INCREF(Py_None); resultobj = Py_None;
10576 return resultobj;
10577 fail:
10578 return NULL;
10579 }
10580
10581
10582 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10583 PyObject *resultobj;
10584 wxGrid *arg1 = (wxGrid *) 0 ;
10585 int result;
10586 PyObject * obj0 = 0 ;
10587 char *kwnames[] = {
10588 (char *) "self", NULL
10589 };
10590
10591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10593 if (SWIG_arg_fail(1)) SWIG_fail;
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = (int)(arg1)->GetBatchCount();
10597
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 {
10602 resultobj = SWIG_From_int((int)(result));
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj;
10612 wxGrid *arg1 = (wxGrid *) 0 ;
10613 PyObject * obj0 = 0 ;
10614 char *kwnames[] = {
10615 (char *) "self", NULL
10616 };
10617
10618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10620 if (SWIG_arg_fail(1)) SWIG_fail;
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 (arg1)->ForceRefresh();
10624
10625 wxPyEndAllowThreads(__tstate);
10626 if (PyErr_Occurred()) SWIG_fail;
10627 }
10628 Py_INCREF(Py_None); resultobj = Py_None;
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj;
10637 wxGrid *arg1 = (wxGrid *) 0 ;
10638 bool result;
10639 PyObject * obj0 = 0 ;
10640 char *kwnames[] = {
10641 (char *) "self", NULL
10642 };
10643
10644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10646 if (SWIG_arg_fail(1)) SWIG_fail;
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (bool)(arg1)->IsEditable();
10650
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 {
10655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10656 }
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj;
10665 wxGrid *arg1 = (wxGrid *) 0 ;
10666 bool arg2 ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char *kwnames[] = {
10670 (char *) "self",(char *) "edit", NULL
10671 };
10672
10673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(1)) SWIG_fail;
10676 {
10677 arg2 = (bool)(SWIG_As_bool(obj1));
10678 if (SWIG_arg_fail(2)) SWIG_fail;
10679 }
10680 {
10681 PyThreadState* __tstate = wxPyBeginAllowThreads();
10682 (arg1)->EnableEditing(arg2);
10683
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 Py_INCREF(Py_None); resultobj = Py_None;
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj;
10696 wxGrid *arg1 = (wxGrid *) 0 ;
10697 bool arg2 = (bool) true ;
10698 PyObject * obj0 = 0 ;
10699 PyObject * obj1 = 0 ;
10700 char *kwnames[] = {
10701 (char *) "self",(char *) "enable", NULL
10702 };
10703
10704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 if (obj1) {
10708 {
10709 arg2 = (bool)(SWIG_As_bool(obj1));
10710 if (SWIG_arg_fail(2)) SWIG_fail;
10711 }
10712 }
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 (arg1)->EnableCellEditControl(arg2);
10716
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 Py_INCREF(Py_None); resultobj = Py_None;
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj;
10729 wxGrid *arg1 = (wxGrid *) 0 ;
10730 PyObject * obj0 = 0 ;
10731 char *kwnames[] = {
10732 (char *) "self", NULL
10733 };
10734
10735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10737 if (SWIG_arg_fail(1)) SWIG_fail;
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 (arg1)->DisableCellEditControl();
10741
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 Py_INCREF(Py_None); resultobj = Py_None;
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj;
10754 wxGrid *arg1 = (wxGrid *) 0 ;
10755 bool result;
10756 PyObject * obj0 = 0 ;
10757 char *kwnames[] = {
10758 (char *) "self", NULL
10759 };
10760
10761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10763 if (SWIG_arg_fail(1)) SWIG_fail;
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10767
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 {
10772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10773 }
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 wxGrid *arg1 = (wxGrid *) 0 ;
10783 bool result;
10784 PyObject * obj0 = 0 ;
10785 char *kwnames[] = {
10786 (char *) "self", NULL
10787 };
10788
10789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
10790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10791 if (SWIG_arg_fail(1)) SWIG_fail;
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
10795
10796 wxPyEndAllowThreads(__tstate);
10797 if (PyErr_Occurred()) SWIG_fail;
10798 }
10799 {
10800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10801 }
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj;
10810 wxGrid *arg1 = (wxGrid *) 0 ;
10811 bool result;
10812 PyObject * obj0 = 0 ;
10813 char *kwnames[] = {
10814 (char *) "self", NULL
10815 };
10816
10817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
10818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 {
10828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxGrid *arg1 = (wxGrid *) 0 ;
10839 bool result;
10840 PyObject * obj0 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
10851
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10857 }
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 wxGrid *arg1 = (wxGrid *) 0 ;
10867 PyObject * obj0 = 0 ;
10868 char *kwnames[] = {
10869 (char *) "self", NULL
10870 };
10871
10872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
10873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10874 if (SWIG_arg_fail(1)) SWIG_fail;
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 (arg1)->ShowCellEditControl();
10878
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 Py_INCREF(Py_None); resultobj = Py_None;
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj;
10891 wxGrid *arg1 = (wxGrid *) 0 ;
10892 PyObject * obj0 = 0 ;
10893 char *kwnames[] = {
10894 (char *) "self", NULL
10895 };
10896
10897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
10898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10899 if (SWIG_arg_fail(1)) SWIG_fail;
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 (arg1)->HideCellEditControl();
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 Py_INCREF(Py_None); resultobj = Py_None;
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj;
10916 wxGrid *arg1 = (wxGrid *) 0 ;
10917 PyObject * obj0 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->SaveEditControlValue();
10928
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxGrid *arg1 = (wxGrid *) 0 ;
10942 int arg2 ;
10943 int arg3 ;
10944 wxGridCellCoords result;
10945 PyObject * obj0 = 0 ;
10946 PyObject * obj1 = 0 ;
10947 PyObject * obj2 = 0 ;
10948 char *kwnames[] = {
10949 (char *) "self",(char *) "x",(char *) "y", NULL
10950 };
10951
10952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
10953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10954 if (SWIG_arg_fail(1)) SWIG_fail;
10955 {
10956 arg2 = (int)(SWIG_As_int(obj1));
10957 if (SWIG_arg_fail(2)) SWIG_fail;
10958 }
10959 {
10960 arg3 = (int)(SWIG_As_int(obj2));
10961 if (SWIG_arg_fail(3)) SWIG_fail;
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 result = wxGrid_XYToCell(arg1,arg2,arg3);
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 wxGridCellCoords * resultptr;
10972 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
10973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj;
10983 wxGrid *arg1 = (wxGrid *) 0 ;
10984 int arg2 ;
10985 int result;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 char *kwnames[] = {
10989 (char *) "self",(char *) "y", NULL
10990 };
10991
10992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
10993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10994 if (SWIG_arg_fail(1)) SWIG_fail;
10995 {
10996 arg2 = (int)(SWIG_As_int(obj1));
10997 if (SWIG_arg_fail(2)) SWIG_fail;
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (int)(arg1)->YToRow(arg2);
11002
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = SWIG_From_int((int)(result));
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxGrid *arg1 = (wxGrid *) 0 ;
11018 int arg2 ;
11019 int result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self",(char *) "x", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 arg2 = (int)(SWIG_As_int(obj1));
11031 if (SWIG_arg_fail(2)) SWIG_fail;
11032 }
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (int)(arg1)->XToCol(arg2);
11036
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 {
11041 resultobj = SWIG_From_int((int)(result));
11042 }
11043 return resultobj;
11044 fail:
11045 return NULL;
11046 }
11047
11048
11049 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11050 PyObject *resultobj;
11051 wxGrid *arg1 = (wxGrid *) 0 ;
11052 int arg2 ;
11053 int result;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 char *kwnames[] = {
11057 (char *) "self",(char *) "y", NULL
11058 };
11059
11060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11062 if (SWIG_arg_fail(1)) SWIG_fail;
11063 {
11064 arg2 = (int)(SWIG_As_int(obj1));
11065 if (SWIG_arg_fail(2)) SWIG_fail;
11066 }
11067 {
11068 PyThreadState* __tstate = wxPyBeginAllowThreads();
11069 result = (int)(arg1)->YToEdgeOfRow(arg2);
11070
11071 wxPyEndAllowThreads(__tstate);
11072 if (PyErr_Occurred()) SWIG_fail;
11073 }
11074 {
11075 resultobj = SWIG_From_int((int)(result));
11076 }
11077 return resultobj;
11078 fail:
11079 return NULL;
11080 }
11081
11082
11083 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11084 PyObject *resultobj;
11085 wxGrid *arg1 = (wxGrid *) 0 ;
11086 int arg2 ;
11087 int result;
11088 PyObject * obj0 = 0 ;
11089 PyObject * obj1 = 0 ;
11090 char *kwnames[] = {
11091 (char *) "self",(char *) "x", NULL
11092 };
11093
11094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11096 if (SWIG_arg_fail(1)) SWIG_fail;
11097 {
11098 arg2 = (int)(SWIG_As_int(obj1));
11099 if (SWIG_arg_fail(2)) SWIG_fail;
11100 }
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 result = (int)(arg1)->XToEdgeOfCol(arg2);
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 {
11109 resultobj = SWIG_From_int((int)(result));
11110 }
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11118 PyObject *resultobj;
11119 wxGrid *arg1 = (wxGrid *) 0 ;
11120 int arg2 ;
11121 int arg3 ;
11122 wxRect result;
11123 PyObject * obj0 = 0 ;
11124 PyObject * obj1 = 0 ;
11125 PyObject * obj2 = 0 ;
11126 char *kwnames[] = {
11127 (char *) "self",(char *) "row",(char *) "col", NULL
11128 };
11129
11130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11132 if (SWIG_arg_fail(1)) SWIG_fail;
11133 {
11134 arg2 = (int)(SWIG_As_int(obj1));
11135 if (SWIG_arg_fail(2)) SWIG_fail;
11136 }
11137 {
11138 arg3 = (int)(SWIG_As_int(obj2));
11139 if (SWIG_arg_fail(3)) SWIG_fail;
11140 }
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 result = (arg1)->CellToRect(arg2,arg3);
11144
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 {
11149 wxRect * resultptr;
11150 resultptr = new wxRect((wxRect &)(result));
11151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11152 }
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj;
11161 wxGrid *arg1 = (wxGrid *) 0 ;
11162 int result;
11163 PyObject * obj0 = 0 ;
11164 char *kwnames[] = {
11165 (char *) "self", NULL
11166 };
11167
11168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11170 if (SWIG_arg_fail(1)) SWIG_fail;
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 result = (int)(arg1)->GetGridCursorRow();
11174
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 {
11179 resultobj = SWIG_From_int((int)(result));
11180 }
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj;
11189 wxGrid *arg1 = (wxGrid *) 0 ;
11190 int result;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 result = (int)(arg1)->GetGridCursorCol();
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 {
11207 resultobj = SWIG_From_int((int)(result));
11208 }
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 wxGrid *arg1 = (wxGrid *) 0 ;
11218 int arg2 ;
11219 int arg3 ;
11220 bool arg4 = (bool) true ;
11221 bool result;
11222 PyObject * obj0 = 0 ;
11223 PyObject * obj1 = 0 ;
11224 PyObject * obj2 = 0 ;
11225 PyObject * obj3 = 0 ;
11226 char *kwnames[] = {
11227 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11228 };
11229
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 {
11234 arg2 = (int)(SWIG_As_int(obj1));
11235 if (SWIG_arg_fail(2)) SWIG_fail;
11236 }
11237 {
11238 arg3 = (int)(SWIG_As_int(obj2));
11239 if (SWIG_arg_fail(3)) SWIG_fail;
11240 }
11241 if (obj3) {
11242 {
11243 arg4 = (bool)(SWIG_As_bool(obj3));
11244 if (SWIG_arg_fail(4)) SWIG_fail;
11245 }
11246 }
11247 {
11248 PyThreadState* __tstate = wxPyBeginAllowThreads();
11249 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11250
11251 wxPyEndAllowThreads(__tstate);
11252 if (PyErr_Occurred()) SWIG_fail;
11253 }
11254 {
11255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11256 }
11257 return resultobj;
11258 fail:
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj;
11265 wxGrid *arg1 = (wxGrid *) 0 ;
11266 int arg2 ;
11267 int arg3 ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 PyObject * obj2 = 0 ;
11271 char *kwnames[] = {
11272 (char *) "self",(char *) "row",(char *) "col", NULL
11273 };
11274
11275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11277 if (SWIG_arg_fail(1)) SWIG_fail;
11278 {
11279 arg2 = (int)(SWIG_As_int(obj1));
11280 if (SWIG_arg_fail(2)) SWIG_fail;
11281 }
11282 {
11283 arg3 = (int)(SWIG_As_int(obj2));
11284 if (SWIG_arg_fail(3)) SWIG_fail;
11285 }
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 (arg1)->MakeCellVisible(arg2,arg3);
11289
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 Py_INCREF(Py_None); resultobj = Py_None;
11294 return resultobj;
11295 fail:
11296 return NULL;
11297 }
11298
11299
11300 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj;
11302 wxGrid *arg1 = (wxGrid *) 0 ;
11303 int arg2 ;
11304 int arg3 ;
11305 PyObject * obj0 = 0 ;
11306 PyObject * obj1 = 0 ;
11307 PyObject * obj2 = 0 ;
11308 char *kwnames[] = {
11309 (char *) "self",(char *) "row",(char *) "col", NULL
11310 };
11311
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 {
11316 arg2 = (int)(SWIG_As_int(obj1));
11317 if (SWIG_arg_fail(2)) SWIG_fail;
11318 }
11319 {
11320 arg3 = (int)(SWIG_As_int(obj2));
11321 if (SWIG_arg_fail(3)) SWIG_fail;
11322 }
11323 {
11324 PyThreadState* __tstate = wxPyBeginAllowThreads();
11325 (arg1)->SetGridCursor(arg2,arg3);
11326
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 Py_INCREF(Py_None); resultobj = Py_None;
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj;
11339 wxGrid *arg1 = (wxGrid *) 0 ;
11340 bool arg2 ;
11341 bool result;
11342 PyObject * obj0 = 0 ;
11343 PyObject * obj1 = 0 ;
11344 char *kwnames[] = {
11345 (char *) "self",(char *) "expandSelection", NULL
11346 };
11347
11348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11350 if (SWIG_arg_fail(1)) SWIG_fail;
11351 {
11352 arg2 = (bool)(SWIG_As_bool(obj1));
11353 if (SWIG_arg_fail(2)) SWIG_fail;
11354 }
11355 {
11356 PyThreadState* __tstate = wxPyBeginAllowThreads();
11357 result = (bool)(arg1)->MoveCursorUp(arg2);
11358
11359 wxPyEndAllowThreads(__tstate);
11360 if (PyErr_Occurred()) SWIG_fail;
11361 }
11362 {
11363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11364 }
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj;
11373 wxGrid *arg1 = (wxGrid *) 0 ;
11374 bool arg2 ;
11375 bool result;
11376 PyObject * obj0 = 0 ;
11377 PyObject * obj1 = 0 ;
11378 char *kwnames[] = {
11379 (char *) "self",(char *) "expandSelection", NULL
11380 };
11381
11382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11384 if (SWIG_arg_fail(1)) SWIG_fail;
11385 {
11386 arg2 = (bool)(SWIG_As_bool(obj1));
11387 if (SWIG_arg_fail(2)) SWIG_fail;
11388 }
11389 {
11390 PyThreadState* __tstate = wxPyBeginAllowThreads();
11391 result = (bool)(arg1)->MoveCursorDown(arg2);
11392
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 {
11397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj;
11407 wxGrid *arg1 = (wxGrid *) 0 ;
11408 bool arg2 ;
11409 bool result;
11410 PyObject * obj0 = 0 ;
11411 PyObject * obj1 = 0 ;
11412 char *kwnames[] = {
11413 (char *) "self",(char *) "expandSelection", NULL
11414 };
11415
11416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 {
11420 arg2 = (bool)(SWIG_As_bool(obj1));
11421 if (SWIG_arg_fail(2)) SWIG_fail;
11422 }
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (bool)(arg1)->MoveCursorLeft(arg2);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 {
11431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11432 }
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11440 PyObject *resultobj;
11441 wxGrid *arg1 = (wxGrid *) 0 ;
11442 bool arg2 ;
11443 bool result;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self",(char *) "expandSelection", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 arg2 = (bool)(SWIG_As_bool(obj1));
11455 if (SWIG_arg_fail(2)) SWIG_fail;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (bool)(arg1)->MoveCursorRight(arg2);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxGrid *arg1 = (wxGrid *) 0 ;
11476 bool result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (bool)(arg1)->MovePageDown();
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxGrid *arg1 = (wxGrid *) 0 ;
11504 bool result;
11505 PyObject * obj0 = 0 ;
11506 char *kwnames[] = {
11507 (char *) "self", NULL
11508 };
11509
11510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11512 if (SWIG_arg_fail(1)) SWIG_fail;
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (bool)(arg1)->MovePageUp();
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11522 }
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 static PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj;
11531 wxGrid *arg1 = (wxGrid *) 0 ;
11532 bool arg2 ;
11533 bool result;
11534 PyObject * obj0 = 0 ;
11535 PyObject * obj1 = 0 ;
11536 char *kwnames[] = {
11537 (char *) "self",(char *) "expandSelection", NULL
11538 };
11539
11540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) goto fail;
11541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11542 if (SWIG_arg_fail(1)) SWIG_fail;
11543 {
11544 arg2 = (bool)(SWIG_As_bool(obj1));
11545 if (SWIG_arg_fail(2)) SWIG_fail;
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
11550
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxGrid *arg1 = (wxGrid *) 0 ;
11566 bool arg2 ;
11567 bool result;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self",(char *) "expandSelection", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 arg2 = (bool)(SWIG_As_bool(obj1));
11579 if (SWIG_arg_fail(2)) SWIG_fail;
11580 }
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
11584
11585 wxPyEndAllowThreads(__tstate);
11586 if (PyErr_Occurred()) SWIG_fail;
11587 }
11588 {
11589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11590 }
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxGrid *arg1 = (wxGrid *) 0 ;
11600 bool arg2 ;
11601 bool result;
11602 PyObject * obj0 = 0 ;
11603 PyObject * obj1 = 0 ;
11604 char *kwnames[] = {
11605 (char *) "self",(char *) "expandSelection", NULL
11606 };
11607
11608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) goto fail;
11609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11610 if (SWIG_arg_fail(1)) SWIG_fail;
11611 {
11612 arg2 = (bool)(SWIG_As_bool(obj1));
11613 if (SWIG_arg_fail(2)) SWIG_fail;
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxGrid *arg1 = (wxGrid *) 0 ;
11634 bool arg2 ;
11635 bool result;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 char *kwnames[] = {
11639 (char *) "self",(char *) "expandSelection", NULL
11640 };
11641
11642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11644 if (SWIG_arg_fail(1)) SWIG_fail;
11645 {
11646 arg2 = (bool)(SWIG_As_bool(obj1));
11647 if (SWIG_arg_fail(2)) SWIG_fail;
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11652
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11658 }
11659 return resultobj;
11660 fail:
11661 return NULL;
11662 }
11663
11664
11665 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj;
11667 wxGrid *arg1 = (wxGrid *) 0 ;
11668 int result;
11669 PyObject * obj0 = 0 ;
11670 char *kwnames[] = {
11671 (char *) "self", NULL
11672 };
11673
11674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11676 if (SWIG_arg_fail(1)) SWIG_fail;
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 result = (int)(arg1)->GetDefaultRowLabelSize();
11680
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 {
11685 resultobj = SWIG_From_int((int)(result));
11686 }
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11694 PyObject *resultobj;
11695 wxGrid *arg1 = (wxGrid *) 0 ;
11696 int result;
11697 PyObject * obj0 = 0 ;
11698 char *kwnames[] = {
11699 (char *) "self", NULL
11700 };
11701
11702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11704 if (SWIG_arg_fail(1)) SWIG_fail;
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (int)(arg1)->GetRowLabelSize();
11708
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 {
11713 resultobj = SWIG_From_int((int)(result));
11714 }
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11722 PyObject *resultobj;
11723 wxGrid *arg1 = (wxGrid *) 0 ;
11724 int result;
11725 PyObject * obj0 = 0 ;
11726 char *kwnames[] = {
11727 (char *) "self", NULL
11728 };
11729
11730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11732 if (SWIG_arg_fail(1)) SWIG_fail;
11733 {
11734 PyThreadState* __tstate = wxPyBeginAllowThreads();
11735 result = (int)(arg1)->GetDefaultColLabelSize();
11736
11737 wxPyEndAllowThreads(__tstate);
11738 if (PyErr_Occurred()) SWIG_fail;
11739 }
11740 {
11741 resultobj = SWIG_From_int((int)(result));
11742 }
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj;
11751 wxGrid *arg1 = (wxGrid *) 0 ;
11752 int result;
11753 PyObject * obj0 = 0 ;
11754 char *kwnames[] = {
11755 (char *) "self", NULL
11756 };
11757
11758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11760 if (SWIG_arg_fail(1)) SWIG_fail;
11761 {
11762 PyThreadState* __tstate = wxPyBeginAllowThreads();
11763 result = (int)(arg1)->GetColLabelSize();
11764
11765 wxPyEndAllowThreads(__tstate);
11766 if (PyErr_Occurred()) SWIG_fail;
11767 }
11768 {
11769 resultobj = SWIG_From_int((int)(result));
11770 }
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11778 PyObject *resultobj;
11779 wxGrid *arg1 = (wxGrid *) 0 ;
11780 wxColour result;
11781 PyObject * obj0 = 0 ;
11782 char *kwnames[] = {
11783 (char *) "self", NULL
11784 };
11785
11786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
11787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11788 if (SWIG_arg_fail(1)) SWIG_fail;
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 result = (arg1)->GetLabelBackgroundColour();
11792
11793 wxPyEndAllowThreads(__tstate);
11794 if (PyErr_Occurred()) SWIG_fail;
11795 }
11796 {
11797 wxColour * resultptr;
11798 resultptr = new wxColour((wxColour &)(result));
11799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
11808 PyObject *resultobj;
11809 wxGrid *arg1 = (wxGrid *) 0 ;
11810 wxColour result;
11811 PyObject * obj0 = 0 ;
11812 char *kwnames[] = {
11813 (char *) "self", NULL
11814 };
11815
11816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
11817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11818 if (SWIG_arg_fail(1)) SWIG_fail;
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (arg1)->GetLabelTextColour();
11822
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 {
11827 wxColour * resultptr;
11828 resultptr = new wxColour((wxColour &)(result));
11829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
11830 }
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
11838 PyObject *resultobj;
11839 wxGrid *arg1 = (wxGrid *) 0 ;
11840 wxFont result;
11841 PyObject * obj0 = 0 ;
11842 char *kwnames[] = {
11843 (char *) "self", NULL
11844 };
11845
11846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
11847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11848 if (SWIG_arg_fail(1)) SWIG_fail;
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (arg1)->GetLabelFont();
11852
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 wxFont * resultptr;
11858 resultptr = new wxFont((wxFont &)(result));
11859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
11860 }
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj;
11869 wxGrid *arg1 = (wxGrid *) 0 ;
11870 int *arg2 = (int *) 0 ;
11871 int *arg3 = (int *) 0 ;
11872 int temp2 ;
11873 int res2 = 0 ;
11874 int temp3 ;
11875 int res3 = 0 ;
11876 PyObject * obj0 = 0 ;
11877 char *kwnames[] = {
11878 (char *) "self", NULL
11879 };
11880
11881 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11882 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
11884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11885 if (SWIG_arg_fail(1)) SWIG_fail;
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 (arg1)->GetRowLabelAlignment(arg2,arg3);
11889
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 Py_INCREF(Py_None); resultobj = Py_None;
11894 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11895 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11896 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11897 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxGrid *arg1 = (wxGrid *) 0 ;
11907 int *arg2 = (int *) 0 ;
11908 int *arg3 = (int *) 0 ;
11909 int temp2 ;
11910 int res2 = 0 ;
11911 int temp3 ;
11912 int res3 = 0 ;
11913 PyObject * obj0 = 0 ;
11914 char *kwnames[] = {
11915 (char *) "self", NULL
11916 };
11917
11918 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11919 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
11921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11922 if (SWIG_arg_fail(1)) SWIG_fail;
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 (arg1)->GetColLabelAlignment(arg2,arg3);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 Py_INCREF(Py_None); resultobj = Py_None;
11931 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11932 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
11933 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11934 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
11935 return resultobj;
11936 fail:
11937 return NULL;
11938 }
11939
11940
11941 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
11942 PyObject *resultobj;
11943 wxGrid *arg1 = (wxGrid *) 0 ;
11944 int result;
11945 PyObject * obj0 = 0 ;
11946 char *kwnames[] = {
11947 (char *) "self", NULL
11948 };
11949
11950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
11951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11952 if (SWIG_arg_fail(1)) SWIG_fail;
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 result = (int)(arg1)->GetColLabelTextOrientation();
11956
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 {
11961 resultobj = SWIG_From_int((int)(result));
11962 }
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj;
11971 wxGrid *arg1 = (wxGrid *) 0 ;
11972 int arg2 ;
11973 wxString result;
11974 PyObject * obj0 = 0 ;
11975 PyObject * obj1 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self",(char *) "row", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 arg2 = (int)(SWIG_As_int(obj1));
11985 if (SWIG_arg_fail(2)) SWIG_fail;
11986 }
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (arg1)->GetRowLabelValue(arg2);
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 #if wxUSE_UNICODE
11996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11997 #else
11998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11999 #endif
12000 }
12001 return resultobj;
12002 fail:
12003 return NULL;
12004 }
12005
12006
12007 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12008 PyObject *resultobj;
12009 wxGrid *arg1 = (wxGrid *) 0 ;
12010 int arg2 ;
12011 wxString result;
12012 PyObject * obj0 = 0 ;
12013 PyObject * obj1 = 0 ;
12014 char *kwnames[] = {
12015 (char *) "self",(char *) "col", NULL
12016 };
12017
12018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12020 if (SWIG_arg_fail(1)) SWIG_fail;
12021 {
12022 arg2 = (int)(SWIG_As_int(obj1));
12023 if (SWIG_arg_fail(2)) SWIG_fail;
12024 }
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 result = (arg1)->GetColLabelValue(arg2);
12028
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 {
12033 #if wxUSE_UNICODE
12034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12035 #else
12036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12037 #endif
12038 }
12039 return resultobj;
12040 fail:
12041 return NULL;
12042 }
12043
12044
12045 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12046 PyObject *resultobj;
12047 wxGrid *arg1 = (wxGrid *) 0 ;
12048 wxColour result;
12049 PyObject * obj0 = 0 ;
12050 char *kwnames[] = {
12051 (char *) "self", NULL
12052 };
12053
12054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12056 if (SWIG_arg_fail(1)) SWIG_fail;
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 result = (arg1)->GetGridLineColour();
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 wxColour * resultptr;
12066 resultptr = new wxColour((wxColour &)(result));
12067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12068 }
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj;
12077 wxGrid *arg1 = (wxGrid *) 0 ;
12078 wxColour result;
12079 PyObject * obj0 = 0 ;
12080 char *kwnames[] = {
12081 (char *) "self", NULL
12082 };
12083
12084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12086 if (SWIG_arg_fail(1)) SWIG_fail;
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (arg1)->GetCellHighlightColour();
12090
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 {
12095 wxColour * resultptr;
12096 resultptr = new wxColour((wxColour &)(result));
12097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12098 }
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj;
12107 wxGrid *arg1 = (wxGrid *) 0 ;
12108 int result;
12109 PyObject * obj0 = 0 ;
12110 char *kwnames[] = {
12111 (char *) "self", NULL
12112 };
12113
12114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12116 if (SWIG_arg_fail(1)) SWIG_fail;
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (int)(arg1)->GetCellHighlightPenWidth();
12120
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = SWIG_From_int((int)(result));
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj;
12135 wxGrid *arg1 = (wxGrid *) 0 ;
12136 int result;
12137 PyObject * obj0 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (int)(arg1)->GetCellHighlightROPenWidth();
12148
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 {
12153 resultobj = SWIG_From_int((int)(result));
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxGrid *arg1 = (wxGrid *) 0 ;
12164 int arg2 ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self",(char *) "width", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 arg2 = (int)(SWIG_As_int(obj1));
12176 if (SWIG_arg_fail(2)) SWIG_fail;
12177 }
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 (arg1)->SetRowLabelSize(arg2);
12181
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 Py_INCREF(Py_None); resultobj = Py_None;
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj;
12194 wxGrid *arg1 = (wxGrid *) 0 ;
12195 int arg2 ;
12196 PyObject * obj0 = 0 ;
12197 PyObject * obj1 = 0 ;
12198 char *kwnames[] = {
12199 (char *) "self",(char *) "height", NULL
12200 };
12201
12202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12204 if (SWIG_arg_fail(1)) SWIG_fail;
12205 {
12206 arg2 = (int)(SWIG_As_int(obj1));
12207 if (SWIG_arg_fail(2)) SWIG_fail;
12208 }
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 (arg1)->SetColLabelSize(arg2);
12212
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 Py_INCREF(Py_None); resultobj = Py_None;
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj;
12225 wxGrid *arg1 = (wxGrid *) 0 ;
12226 wxColour *arg2 = 0 ;
12227 wxColour temp2 ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 char *kwnames[] = {
12231 (char *) "self","arg2", NULL
12232 };
12233
12234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12236 if (SWIG_arg_fail(1)) SWIG_fail;
12237 {
12238 arg2 = &temp2;
12239 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12240 }
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 Py_INCREF(Py_None); resultobj = Py_None;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxGrid *arg1 = (wxGrid *) 0 ;
12258 wxColour *arg2 = 0 ;
12259 wxColour temp2 ;
12260 PyObject * obj0 = 0 ;
12261 PyObject * obj1 = 0 ;
12262 char *kwnames[] = {
12263 (char *) "self","arg2", NULL
12264 };
12265
12266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) goto fail;
12267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12268 if (SWIG_arg_fail(1)) SWIG_fail;
12269 {
12270 arg2 = &temp2;
12271 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12272 }
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
12276
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 Py_INCREF(Py_None); resultobj = Py_None;
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Grid_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj;
12289 wxGrid *arg1 = (wxGrid *) 0 ;
12290 wxFont *arg2 = 0 ;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "self","arg2", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12299 if (SWIG_arg_fail(1)) SWIG_fail;
12300 {
12301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12302 if (SWIG_arg_fail(2)) SWIG_fail;
12303 if (arg2 == NULL) {
12304 SWIG_null_ref("wxFont");
12305 }
12306 if (SWIG_arg_fail(2)) SWIG_fail;
12307 }
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 (arg1)->SetLabelFont((wxFont const &)*arg2);
12311
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 Py_INCREF(Py_None); resultobj = Py_None;
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj;
12324 wxGrid *arg1 = (wxGrid *) 0 ;
12325 int arg2 ;
12326 int arg3 ;
12327 PyObject * obj0 = 0 ;
12328 PyObject * obj1 = 0 ;
12329 PyObject * obj2 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 arg2 = (int)(SWIG_As_int(obj1));
12339 if (SWIG_arg_fail(2)) SWIG_fail;
12340 }
12341 {
12342 arg3 = (int)(SWIG_As_int(obj2));
12343 if (SWIG_arg_fail(3)) SWIG_fail;
12344 }
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 (arg1)->SetRowLabelAlignment(arg2,arg3);
12348
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 Py_INCREF(Py_None); resultobj = Py_None;
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj;
12361 wxGrid *arg1 = (wxGrid *) 0 ;
12362 int arg2 ;
12363 int arg3 ;
12364 PyObject * obj0 = 0 ;
12365 PyObject * obj1 = 0 ;
12366 PyObject * obj2 = 0 ;
12367 char *kwnames[] = {
12368 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12369 };
12370
12371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12373 if (SWIG_arg_fail(1)) SWIG_fail;
12374 {
12375 arg2 = (int)(SWIG_As_int(obj1));
12376 if (SWIG_arg_fail(2)) SWIG_fail;
12377 }
12378 {
12379 arg3 = (int)(SWIG_As_int(obj2));
12380 if (SWIG_arg_fail(3)) SWIG_fail;
12381 }
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 (arg1)->SetColLabelAlignment(arg2,arg3);
12385
12386 wxPyEndAllowThreads(__tstate);
12387 if (PyErr_Occurred()) SWIG_fail;
12388 }
12389 Py_INCREF(Py_None); resultobj = Py_None;
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj;
12398 wxGrid *arg1 = (wxGrid *) 0 ;
12399 int arg2 ;
12400 PyObject * obj0 = 0 ;
12401 PyObject * obj1 = 0 ;
12402 char *kwnames[] = {
12403 (char *) "self",(char *) "textOrientation", NULL
12404 };
12405
12406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12408 if (SWIG_arg_fail(1)) SWIG_fail;
12409 {
12410 arg2 = (int)(SWIG_As_int(obj1));
12411 if (SWIG_arg_fail(2)) SWIG_fail;
12412 }
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 (arg1)->SetColLabelTextOrientation(arg2);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 Py_INCREF(Py_None); resultobj = Py_None;
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxGrid *arg1 = (wxGrid *) 0 ;
12430 int arg2 ;
12431 wxString *arg3 = 0 ;
12432 bool temp3 = false ;
12433 PyObject * obj0 = 0 ;
12434 PyObject * obj1 = 0 ;
12435 PyObject * obj2 = 0 ;
12436 char *kwnames[] = {
12437 (char *) "self",(char *) "row","arg3", NULL
12438 };
12439
12440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12442 if (SWIG_arg_fail(1)) SWIG_fail;
12443 {
12444 arg2 = (int)(SWIG_As_int(obj1));
12445 if (SWIG_arg_fail(2)) SWIG_fail;
12446 }
12447 {
12448 arg3 = wxString_in_helper(obj2);
12449 if (arg3 == NULL) SWIG_fail;
12450 temp3 = true;
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 Py_INCREF(Py_None); resultobj = Py_None;
12460 {
12461 if (temp3)
12462 delete arg3;
12463 }
12464 return resultobj;
12465 fail:
12466 {
12467 if (temp3)
12468 delete arg3;
12469 }
12470 return NULL;
12471 }
12472
12473
12474 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj;
12476 wxGrid *arg1 = (wxGrid *) 0 ;
12477 int arg2 ;
12478 wxString *arg3 = 0 ;
12479 bool temp3 = false ;
12480 PyObject * obj0 = 0 ;
12481 PyObject * obj1 = 0 ;
12482 PyObject * obj2 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self",(char *) "col","arg3", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 arg2 = (int)(SWIG_As_int(obj1));
12492 if (SWIG_arg_fail(2)) SWIG_fail;
12493 }
12494 {
12495 arg3 = wxString_in_helper(obj2);
12496 if (arg3 == NULL) SWIG_fail;
12497 temp3 = true;
12498 }
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12502
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 Py_INCREF(Py_None); resultobj = Py_None;
12507 {
12508 if (temp3)
12509 delete arg3;
12510 }
12511 return resultobj;
12512 fail:
12513 {
12514 if (temp3)
12515 delete arg3;
12516 }
12517 return NULL;
12518 }
12519
12520
12521 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12522 PyObject *resultobj;
12523 wxGrid *arg1 = (wxGrid *) 0 ;
12524 wxColour *arg2 = 0 ;
12525 wxColour temp2 ;
12526 PyObject * obj0 = 0 ;
12527 PyObject * obj1 = 0 ;
12528 char *kwnames[] = {
12529 (char *) "self","arg2", NULL
12530 };
12531
12532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12534 if (SWIG_arg_fail(1)) SWIG_fail;
12535 {
12536 arg2 = &temp2;
12537 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12538 }
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12542
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 Py_INCREF(Py_None); resultobj = Py_None;
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxGrid *arg1 = (wxGrid *) 0 ;
12556 wxColour *arg2 = 0 ;
12557 wxColour temp2 ;
12558 PyObject * obj0 = 0 ;
12559 PyObject * obj1 = 0 ;
12560 char *kwnames[] = {
12561 (char *) "self","arg2", NULL
12562 };
12563
12564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) goto fail;
12565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12566 if (SWIG_arg_fail(1)) SWIG_fail;
12567 {
12568 arg2 = &temp2;
12569 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12570 }
12571 {
12572 PyThreadState* __tstate = wxPyBeginAllowThreads();
12573 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
12574
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 Py_INCREF(Py_None); resultobj = Py_None;
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 static PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj;
12587 wxGrid *arg1 = (wxGrid *) 0 ;
12588 int arg2 ;
12589 PyObject * obj0 = 0 ;
12590 PyObject * obj1 = 0 ;
12591 char *kwnames[] = {
12592 (char *) "self",(char *) "width", NULL
12593 };
12594
12595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12597 if (SWIG_arg_fail(1)) SWIG_fail;
12598 {
12599 arg2 = (int)(SWIG_As_int(obj1));
12600 if (SWIG_arg_fail(2)) SWIG_fail;
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 (arg1)->SetCellHighlightPenWidth(arg2);
12605
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 Py_INCREF(Py_None); resultobj = Py_None;
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj;
12618 wxGrid *arg1 = (wxGrid *) 0 ;
12619 int arg2 ;
12620 PyObject * obj0 = 0 ;
12621 PyObject * obj1 = 0 ;
12622 char *kwnames[] = {
12623 (char *) "self",(char *) "width", NULL
12624 };
12625
12626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12628 if (SWIG_arg_fail(1)) SWIG_fail;
12629 {
12630 arg2 = (int)(SWIG_As_int(obj1));
12631 if (SWIG_arg_fail(2)) SWIG_fail;
12632 }
12633 {
12634 PyThreadState* __tstate = wxPyBeginAllowThreads();
12635 (arg1)->SetCellHighlightROPenWidth(arg2);
12636
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 Py_INCREF(Py_None); resultobj = Py_None;
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj;
12649 wxGrid *arg1 = (wxGrid *) 0 ;
12650 bool arg2 = (bool) true ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 char *kwnames[] = {
12654 (char *) "self",(char *) "enable", NULL
12655 };
12656
12657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12659 if (SWIG_arg_fail(1)) SWIG_fail;
12660 if (obj1) {
12661 {
12662 arg2 = (bool)(SWIG_As_bool(obj1));
12663 if (SWIG_arg_fail(2)) SWIG_fail;
12664 }
12665 }
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 (arg1)->EnableDragRowSize(arg2);
12669
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 Py_INCREF(Py_None); resultobj = Py_None;
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 static PyObject *_wrap_Grid_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12681 PyObject *resultobj;
12682 wxGrid *arg1 = (wxGrid *) 0 ;
12683 PyObject * obj0 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 (arg1)->DisableDragRowSize();
12694
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 Py_INCREF(Py_None); resultobj = Py_None;
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12706 PyObject *resultobj;
12707 wxGrid *arg1 = (wxGrid *) 0 ;
12708 bool result;
12709 PyObject * obj0 = 0 ;
12710 char *kwnames[] = {
12711 (char *) "self", NULL
12712 };
12713
12714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12716 if (SWIG_arg_fail(1)) SWIG_fail;
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 result = (bool)(arg1)->CanDragRowSize();
12720
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 {
12725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12726 }
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12734 PyObject *resultobj;
12735 wxGrid *arg1 = (wxGrid *) 0 ;
12736 bool arg2 = (bool) true ;
12737 PyObject * obj0 = 0 ;
12738 PyObject * obj1 = 0 ;
12739 char *kwnames[] = {
12740 (char *) "self",(char *) "enable", NULL
12741 };
12742
12743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12745 if (SWIG_arg_fail(1)) SWIG_fail;
12746 if (obj1) {
12747 {
12748 arg2 = (bool)(SWIG_As_bool(obj1));
12749 if (SWIG_arg_fail(2)) SWIG_fail;
12750 }
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 (arg1)->EnableDragColSize(arg2);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 Py_INCREF(Py_None); resultobj = Py_None;
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12767 PyObject *resultobj;
12768 wxGrid *arg1 = (wxGrid *) 0 ;
12769 PyObject * obj0 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(1)) SWIG_fail;
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 (arg1)->DisableDragColSize();
12780
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 Py_INCREF(Py_None); resultobj = Py_None;
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxGrid *arg1 = (wxGrid *) 0 ;
12794 bool result;
12795 PyObject * obj0 = 0 ;
12796 char *kwnames[] = {
12797 (char *) "self", NULL
12798 };
12799
12800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
12801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12802 if (SWIG_arg_fail(1)) SWIG_fail;
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = (bool)(arg1)->CanDragColSize();
12806
12807 wxPyEndAllowThreads(__tstate);
12808 if (PyErr_Occurred()) SWIG_fail;
12809 }
12810 {
12811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12812 }
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12820 PyObject *resultobj;
12821 wxGrid *arg1 = (wxGrid *) 0 ;
12822 bool arg2 = (bool) true ;
12823 PyObject * obj0 = 0 ;
12824 PyObject * obj1 = 0 ;
12825 char *kwnames[] = {
12826 (char *) "self",(char *) "enable", NULL
12827 };
12828
12829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
12830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12831 if (SWIG_arg_fail(1)) SWIG_fail;
12832 if (obj1) {
12833 {
12834 arg2 = (bool)(SWIG_As_bool(obj1));
12835 if (SWIG_arg_fail(2)) SWIG_fail;
12836 }
12837 }
12838 {
12839 PyThreadState* __tstate = wxPyBeginAllowThreads();
12840 (arg1)->EnableDragGridSize(arg2);
12841
12842 wxPyEndAllowThreads(__tstate);
12843 if (PyErr_Occurred()) SWIG_fail;
12844 }
12845 Py_INCREF(Py_None); resultobj = Py_None;
12846 return resultobj;
12847 fail:
12848 return NULL;
12849 }
12850
12851
12852 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12853 PyObject *resultobj;
12854 wxGrid *arg1 = (wxGrid *) 0 ;
12855 PyObject * obj0 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 (arg1)->DisableDragGridSize();
12866
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 Py_INCREF(Py_None); resultobj = Py_None;
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj;
12879 wxGrid *arg1 = (wxGrid *) 0 ;
12880 bool result;
12881 PyObject * obj0 = 0 ;
12882 char *kwnames[] = {
12883 (char *) "self", NULL
12884 };
12885
12886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
12887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12888 if (SWIG_arg_fail(1)) SWIG_fail;
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (bool)(arg1)->CanDragGridSize();
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 {
12897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12898 }
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12906 PyObject *resultobj;
12907 wxGrid *arg1 = (wxGrid *) 0 ;
12908 bool arg2 = (bool) true ;
12909 PyObject * obj0 = 0 ;
12910 PyObject * obj1 = 0 ;
12911 char *kwnames[] = {
12912 (char *) "self",(char *) "enable", NULL
12913 };
12914
12915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
12916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12917 if (SWIG_arg_fail(1)) SWIG_fail;
12918 if (obj1) {
12919 {
12920 arg2 = (bool)(SWIG_As_bool(obj1));
12921 if (SWIG_arg_fail(2)) SWIG_fail;
12922 }
12923 }
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 (arg1)->EnableDragCell(arg2);
12927
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 Py_INCREF(Py_None); resultobj = Py_None;
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj;
12940 wxGrid *arg1 = (wxGrid *) 0 ;
12941 PyObject * obj0 = 0 ;
12942 char *kwnames[] = {
12943 (char *) "self", NULL
12944 };
12945
12946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
12947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12948 if (SWIG_arg_fail(1)) SWIG_fail;
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 (arg1)->DisableDragCell();
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 Py_INCREF(Py_None); resultobj = Py_None;
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxGrid *arg1 = (wxGrid *) 0 ;
12966 bool result;
12967 PyObject * obj0 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (bool)(arg1)->CanDragCell();
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 {
12983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12984 }
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj;
12993 wxGrid *arg1 = (wxGrid *) 0 ;
12994 int arg2 ;
12995 int arg3 ;
12996 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
12997 PyObject * obj0 = 0 ;
12998 PyObject * obj1 = 0 ;
12999 PyObject * obj2 = 0 ;
13000 PyObject * obj3 = 0 ;
13001 char *kwnames[] = {
13002 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
13003 };
13004
13005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13007 if (SWIG_arg_fail(1)) SWIG_fail;
13008 {
13009 arg2 = (int)(SWIG_As_int(obj1));
13010 if (SWIG_arg_fail(2)) SWIG_fail;
13011 }
13012 {
13013 arg3 = (int)(SWIG_As_int(obj2));
13014 if (SWIG_arg_fail(3)) SWIG_fail;
13015 }
13016 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(4)) SWIG_fail;
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 (arg1)->SetAttr(arg2,arg3,arg4);
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 Py_INCREF(Py_None); resultobj = Py_None;
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13033 PyObject *resultobj;
13034 wxGrid *arg1 = (wxGrid *) 0 ;
13035 int arg2 ;
13036 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13037 PyObject * obj0 = 0 ;
13038 PyObject * obj1 = 0 ;
13039 PyObject * obj2 = 0 ;
13040 char *kwnames[] = {
13041 (char *) "self",(char *) "row",(char *) "attr", NULL
13042 };
13043
13044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13046 if (SWIG_arg_fail(1)) SWIG_fail;
13047 {
13048 arg2 = (int)(SWIG_As_int(obj1));
13049 if (SWIG_arg_fail(2)) SWIG_fail;
13050 }
13051 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(3)) SWIG_fail;
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 (arg1)->SetRowAttr(arg2,arg3);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 Py_INCREF(Py_None); resultobj = Py_None;
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxGrid *arg1 = (wxGrid *) 0 ;
13070 int arg2 ;
13071 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 PyObject * obj2 = 0 ;
13075 char *kwnames[] = {
13076 (char *) "self",(char *) "col",(char *) "attr", NULL
13077 };
13078
13079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(1)) SWIG_fail;
13082 {
13083 arg2 = (int)(SWIG_As_int(obj1));
13084 if (SWIG_arg_fail(2)) SWIG_fail;
13085 }
13086 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(3)) SWIG_fail;
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 (arg1)->SetColAttr(arg2,arg3);
13091
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 Py_INCREF(Py_None); resultobj = Py_None;
13096 return resultobj;
13097 fail:
13098 return NULL;
13099 }
13100
13101
13102 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13103 PyObject *resultobj;
13104 wxGrid *arg1 = (wxGrid *) 0 ;
13105 int arg2 ;
13106 int arg3 ;
13107 wxGridCellAttr *result;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 PyObject * obj2 = 0 ;
13111 char *kwnames[] = {
13112 (char *) "self",(char *) "row",(char *) "col", NULL
13113 };
13114
13115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13117 if (SWIG_arg_fail(1)) SWIG_fail;
13118 {
13119 arg2 = (int)(SWIG_As_int(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 {
13123 arg3 = (int)(SWIG_As_int(obj2));
13124 if (SWIG_arg_fail(3)) SWIG_fail;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 {
13134 resultobj = wxPyMake_wxGridCellAttr(result, 0);
13135 }
13136 return resultobj;
13137 fail:
13138 return NULL;
13139 }
13140
13141
13142 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13143 PyObject *resultobj;
13144 wxGrid *arg1 = (wxGrid *) 0 ;
13145 int arg2 ;
13146 PyObject * obj0 = 0 ;
13147 PyObject * obj1 = 0 ;
13148 char *kwnames[] = {
13149 (char *) "self",(char *) "col", NULL
13150 };
13151
13152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13154 if (SWIG_arg_fail(1)) SWIG_fail;
13155 {
13156 arg2 = (int)(SWIG_As_int(obj1));
13157 if (SWIG_arg_fail(2)) SWIG_fail;
13158 }
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 (arg1)->SetColFormatBool(arg2);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 Py_INCREF(Py_None); resultobj = Py_None;
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxGrid *arg1 = (wxGrid *) 0 ;
13176 int arg2 ;
13177 PyObject * obj0 = 0 ;
13178 PyObject * obj1 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "self",(char *) "col", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13185 if (SWIG_arg_fail(1)) SWIG_fail;
13186 {
13187 arg2 = (int)(SWIG_As_int(obj1));
13188 if (SWIG_arg_fail(2)) SWIG_fail;
13189 }
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 (arg1)->SetColFormatNumber(arg2);
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 Py_INCREF(Py_None); resultobj = Py_None;
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj;
13206 wxGrid *arg1 = (wxGrid *) 0 ;
13207 int arg2 ;
13208 int arg3 = (int) -1 ;
13209 int arg4 = (int) -1 ;
13210 PyObject * obj0 = 0 ;
13211 PyObject * obj1 = 0 ;
13212 PyObject * obj2 = 0 ;
13213 PyObject * obj3 = 0 ;
13214 char *kwnames[] = {
13215 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13216 };
13217
13218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13220 if (SWIG_arg_fail(1)) SWIG_fail;
13221 {
13222 arg2 = (int)(SWIG_As_int(obj1));
13223 if (SWIG_arg_fail(2)) SWIG_fail;
13224 }
13225 if (obj2) {
13226 {
13227 arg3 = (int)(SWIG_As_int(obj2));
13228 if (SWIG_arg_fail(3)) SWIG_fail;
13229 }
13230 }
13231 if (obj3) {
13232 {
13233 arg4 = (int)(SWIG_As_int(obj3));
13234 if (SWIG_arg_fail(4)) SWIG_fail;
13235 }
13236 }
13237 {
13238 PyThreadState* __tstate = wxPyBeginAllowThreads();
13239 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13240
13241 wxPyEndAllowThreads(__tstate);
13242 if (PyErr_Occurred()) SWIG_fail;
13243 }
13244 Py_INCREF(Py_None); resultobj = Py_None;
13245 return resultobj;
13246 fail:
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxGrid *arg1 = (wxGrid *) 0 ;
13254 int arg2 ;
13255 wxString *arg3 = 0 ;
13256 bool temp3 = false ;
13257 PyObject * obj0 = 0 ;
13258 PyObject * obj1 = 0 ;
13259 PyObject * obj2 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self",(char *) "col",(char *) "typeName", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 arg2 = (int)(SWIG_As_int(obj1));
13269 if (SWIG_arg_fail(2)) SWIG_fail;
13270 }
13271 {
13272 arg3 = wxString_in_helper(obj2);
13273 if (arg3 == NULL) SWIG_fail;
13274 temp3 = true;
13275 }
13276 {
13277 PyThreadState* __tstate = wxPyBeginAllowThreads();
13278 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13279
13280 wxPyEndAllowThreads(__tstate);
13281 if (PyErr_Occurred()) SWIG_fail;
13282 }
13283 Py_INCREF(Py_None); resultobj = Py_None;
13284 {
13285 if (temp3)
13286 delete arg3;
13287 }
13288 return resultobj;
13289 fail:
13290 {
13291 if (temp3)
13292 delete arg3;
13293 }
13294 return NULL;
13295 }
13296
13297
13298 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13299 PyObject *resultobj;
13300 wxGrid *arg1 = (wxGrid *) 0 ;
13301 bool arg2 = (bool) true ;
13302 PyObject * obj0 = 0 ;
13303 PyObject * obj1 = 0 ;
13304 char *kwnames[] = {
13305 (char *) "self",(char *) "enable", NULL
13306 };
13307
13308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13310 if (SWIG_arg_fail(1)) SWIG_fail;
13311 if (obj1) {
13312 {
13313 arg2 = (bool)(SWIG_As_bool(obj1));
13314 if (SWIG_arg_fail(2)) SWIG_fail;
13315 }
13316 }
13317 {
13318 PyThreadState* __tstate = wxPyBeginAllowThreads();
13319 (arg1)->EnableGridLines(arg2);
13320
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 Py_INCREF(Py_None); resultobj = Py_None;
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject *_wrap_Grid_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj;
13333 wxGrid *arg1 = (wxGrid *) 0 ;
13334 bool result;
13335 PyObject * obj0 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "self", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13342 if (SWIG_arg_fail(1)) SWIG_fail;
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (bool)(arg1)->GridLinesEnabled();
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13352 }
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj;
13361 wxGrid *arg1 = (wxGrid *) 0 ;
13362 int result;
13363 PyObject * obj0 = 0 ;
13364 char *kwnames[] = {
13365 (char *) "self", NULL
13366 };
13367
13368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13370 if (SWIG_arg_fail(1)) SWIG_fail;
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (int)(arg1)->GetDefaultRowSize();
13374
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 {
13379 resultobj = SWIG_From_int((int)(result));
13380 }
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj;
13389 wxGrid *arg1 = (wxGrid *) 0 ;
13390 int arg2 ;
13391 int result;
13392 PyObject * obj0 = 0 ;
13393 PyObject * obj1 = 0 ;
13394 char *kwnames[] = {
13395 (char *) "self",(char *) "row", NULL
13396 };
13397
13398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13400 if (SWIG_arg_fail(1)) SWIG_fail;
13401 {
13402 arg2 = (int)(SWIG_As_int(obj1));
13403 if (SWIG_arg_fail(2)) SWIG_fail;
13404 }
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (int)(arg1)->GetRowSize(arg2);
13408
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 {
13413 resultobj = SWIG_From_int((int)(result));
13414 }
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13422 PyObject *resultobj;
13423 wxGrid *arg1 = (wxGrid *) 0 ;
13424 int result;
13425 PyObject * obj0 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "self", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 result = (int)(arg1)->GetDefaultColSize();
13436
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 {
13441 resultobj = SWIG_From_int((int)(result));
13442 }
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj;
13451 wxGrid *arg1 = (wxGrid *) 0 ;
13452 int arg2 ;
13453 int result;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 char *kwnames[] = {
13457 (char *) "self",(char *) "col", NULL
13458 };
13459
13460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13462 if (SWIG_arg_fail(1)) SWIG_fail;
13463 {
13464 arg2 = (int)(SWIG_As_int(obj1));
13465 if (SWIG_arg_fail(2)) SWIG_fail;
13466 }
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 result = (int)(arg1)->GetColSize(arg2);
13470
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 {
13475 resultobj = SWIG_From_int((int)(result));
13476 }
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj;
13485 wxGrid *arg1 = (wxGrid *) 0 ;
13486 wxColour result;
13487 PyObject * obj0 = 0 ;
13488 char *kwnames[] = {
13489 (char *) "self", NULL
13490 };
13491
13492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13494 if (SWIG_arg_fail(1)) SWIG_fail;
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = (arg1)->GetDefaultCellBackgroundColour();
13498
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 {
13503 wxColour * resultptr;
13504 resultptr = new wxColour((wxColour &)(result));
13505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13506 }
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj;
13515 wxGrid *arg1 = (wxGrid *) 0 ;
13516 int arg2 ;
13517 int arg3 ;
13518 wxColour result;
13519 PyObject * obj0 = 0 ;
13520 PyObject * obj1 = 0 ;
13521 PyObject * obj2 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self",(char *) "row",(char *) "col", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 {
13530 arg2 = (int)(SWIG_As_int(obj1));
13531 if (SWIG_arg_fail(2)) SWIG_fail;
13532 }
13533 {
13534 arg3 = (int)(SWIG_As_int(obj2));
13535 if (SWIG_arg_fail(3)) SWIG_fail;
13536 }
13537 {
13538 PyThreadState* __tstate = wxPyBeginAllowThreads();
13539 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13540
13541 wxPyEndAllowThreads(__tstate);
13542 if (PyErr_Occurred()) SWIG_fail;
13543 }
13544 {
13545 wxColour * resultptr;
13546 resultptr = new wxColour((wxColour &)(result));
13547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13548 }
13549 return resultobj;
13550 fail:
13551 return NULL;
13552 }
13553
13554
13555 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13556 PyObject *resultobj;
13557 wxGrid *arg1 = (wxGrid *) 0 ;
13558 wxColour result;
13559 PyObject * obj0 = 0 ;
13560 char *kwnames[] = {
13561 (char *) "self", NULL
13562 };
13563
13564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13566 if (SWIG_arg_fail(1)) SWIG_fail;
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (arg1)->GetDefaultCellTextColour();
13570
13571 wxPyEndAllowThreads(__tstate);
13572 if (PyErr_Occurred()) SWIG_fail;
13573 }
13574 {
13575 wxColour * resultptr;
13576 resultptr = new wxColour((wxColour &)(result));
13577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13578 }
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj;
13587 wxGrid *arg1 = (wxGrid *) 0 ;
13588 int arg2 ;
13589 int arg3 ;
13590 wxColour result;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 PyObject * obj2 = 0 ;
13594 char *kwnames[] = {
13595 (char *) "self",(char *) "row",(char *) "col", NULL
13596 };
13597
13598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13600 if (SWIG_arg_fail(1)) SWIG_fail;
13601 {
13602 arg2 = (int)(SWIG_As_int(obj1));
13603 if (SWIG_arg_fail(2)) SWIG_fail;
13604 }
13605 {
13606 arg3 = (int)(SWIG_As_int(obj2));
13607 if (SWIG_arg_fail(3)) SWIG_fail;
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (arg1)->GetCellTextColour(arg2,arg3);
13612
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 {
13617 wxColour * resultptr;
13618 resultptr = new wxColour((wxColour &)(result));
13619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13620 }
13621 return resultobj;
13622 fail:
13623 return NULL;
13624 }
13625
13626
13627 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13628 PyObject *resultobj;
13629 wxGrid *arg1 = (wxGrid *) 0 ;
13630 wxFont result;
13631 PyObject * obj0 = 0 ;
13632 char *kwnames[] = {
13633 (char *) "self", NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(1)) SWIG_fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (arg1)->GetDefaultCellFont();
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 {
13647 wxFont * resultptr;
13648 resultptr = new wxFont((wxFont &)(result));
13649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13650 }
13651 return resultobj;
13652 fail:
13653 return NULL;
13654 }
13655
13656
13657 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj;
13659 wxGrid *arg1 = (wxGrid *) 0 ;
13660 int arg2 ;
13661 int arg3 ;
13662 wxFont result;
13663 PyObject * obj0 = 0 ;
13664 PyObject * obj1 = 0 ;
13665 PyObject * obj2 = 0 ;
13666 char *kwnames[] = {
13667 (char *) "self",(char *) "row",(char *) "col", NULL
13668 };
13669
13670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13672 if (SWIG_arg_fail(1)) SWIG_fail;
13673 {
13674 arg2 = (int)(SWIG_As_int(obj1));
13675 if (SWIG_arg_fail(2)) SWIG_fail;
13676 }
13677 {
13678 arg3 = (int)(SWIG_As_int(obj2));
13679 if (SWIG_arg_fail(3)) SWIG_fail;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (arg1)->GetCellFont(arg2,arg3);
13684
13685 wxPyEndAllowThreads(__tstate);
13686 if (PyErr_Occurred()) SWIG_fail;
13687 }
13688 {
13689 wxFont * resultptr;
13690 resultptr = new wxFont((wxFont &)(result));
13691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13692 }
13693 return resultobj;
13694 fail:
13695 return NULL;
13696 }
13697
13698
13699 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13700 PyObject *resultobj;
13701 wxGrid *arg1 = (wxGrid *) 0 ;
13702 int *arg2 = (int *) 0 ;
13703 int *arg3 = (int *) 0 ;
13704 int temp2 ;
13705 int res2 = 0 ;
13706 int temp3 ;
13707 int res3 = 0 ;
13708 PyObject * obj0 = 0 ;
13709 char *kwnames[] = {
13710 (char *) "self", NULL
13711 };
13712
13713 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13714 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13717 if (SWIG_arg_fail(1)) SWIG_fail;
13718 {
13719 PyThreadState* __tstate = wxPyBeginAllowThreads();
13720 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13721
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 Py_INCREF(Py_None); resultobj = Py_None;
13726 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13727 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13728 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13729 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj;
13738 wxGrid *arg1 = (wxGrid *) 0 ;
13739 int arg2 ;
13740 int arg3 ;
13741 int *arg4 = (int *) 0 ;
13742 int *arg5 = (int *) 0 ;
13743 int temp4 ;
13744 int res4 = 0 ;
13745 int temp5 ;
13746 int res5 = 0 ;
13747 PyObject * obj0 = 0 ;
13748 PyObject * obj1 = 0 ;
13749 PyObject * obj2 = 0 ;
13750 char *kwnames[] = {
13751 (char *) "self",(char *) "row",(char *) "col", NULL
13752 };
13753
13754 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13755 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
13757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13758 if (SWIG_arg_fail(1)) SWIG_fail;
13759 {
13760 arg2 = (int)(SWIG_As_int(obj1));
13761 if (SWIG_arg_fail(2)) SWIG_fail;
13762 }
13763 {
13764 arg3 = (int)(SWIG_As_int(obj2));
13765 if (SWIG_arg_fail(3)) SWIG_fail;
13766 }
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 Py_INCREF(Py_None); resultobj = Py_None;
13775 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13776 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13777 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13778 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj;
13787 wxGrid *arg1 = (wxGrid *) 0 ;
13788 bool result;
13789 PyObject * obj0 = 0 ;
13790 char *kwnames[] = {
13791 (char *) "self", NULL
13792 };
13793
13794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",kwnames,&obj0)) goto fail;
13795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13796 if (SWIG_arg_fail(1)) SWIG_fail;
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 result = (bool)(arg1)->GetDefaultCellOverflow();
13800
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 {
13805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13806 }
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj;
13815 wxGrid *arg1 = (wxGrid *) 0 ;
13816 int arg2 ;
13817 int arg3 ;
13818 bool result;
13819 PyObject * obj0 = 0 ;
13820 PyObject * obj1 = 0 ;
13821 PyObject * obj2 = 0 ;
13822 char *kwnames[] = {
13823 (char *) "self",(char *) "row",(char *) "col", NULL
13824 };
13825
13826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
13827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13828 if (SWIG_arg_fail(1)) SWIG_fail;
13829 {
13830 arg2 = (int)(SWIG_As_int(obj1));
13831 if (SWIG_arg_fail(2)) SWIG_fail;
13832 }
13833 {
13834 arg3 = (int)(SWIG_As_int(obj2));
13835 if (SWIG_arg_fail(3)) SWIG_fail;
13836 }
13837 {
13838 PyThreadState* __tstate = wxPyBeginAllowThreads();
13839 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
13840
13841 wxPyEndAllowThreads(__tstate);
13842 if (PyErr_Occurred()) SWIG_fail;
13843 }
13844 {
13845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13846 }
13847 return resultobj;
13848 fail:
13849 return NULL;
13850 }
13851
13852
13853 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj;
13855 wxGrid *arg1 = (wxGrid *) 0 ;
13856 int arg2 ;
13857 int arg3 ;
13858 int *arg4 = (int *) 0 ;
13859 int *arg5 = (int *) 0 ;
13860 int temp4 ;
13861 int res4 = 0 ;
13862 int temp5 ;
13863 int res5 = 0 ;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 PyObject * obj2 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self",(char *) "row",(char *) "col", NULL
13869 };
13870
13871 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13872 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13875 if (SWIG_arg_fail(1)) SWIG_fail;
13876 {
13877 arg2 = (int)(SWIG_As_int(obj1));
13878 if (SWIG_arg_fail(2)) SWIG_fail;
13879 }
13880 {
13881 arg3 = (int)(SWIG_As_int(obj2));
13882 if (SWIG_arg_fail(3)) SWIG_fail;
13883 }
13884 {
13885 PyThreadState* __tstate = wxPyBeginAllowThreads();
13886 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
13887
13888 wxPyEndAllowThreads(__tstate);
13889 if (PyErr_Occurred()) SWIG_fail;
13890 }
13891 Py_INCREF(Py_None); resultobj = Py_None;
13892 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13893 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13894 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13895 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13896 return resultobj;
13897 fail:
13898 return NULL;
13899 }
13900
13901
13902 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj;
13904 wxGrid *arg1 = (wxGrid *) 0 ;
13905 int arg2 ;
13906 bool arg3 = (bool) false ;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 PyObject * obj2 = 0 ;
13910 char *kwnames[] = {
13911 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13916 if (SWIG_arg_fail(1)) SWIG_fail;
13917 {
13918 arg2 = (int)(SWIG_As_int(obj1));
13919 if (SWIG_arg_fail(2)) SWIG_fail;
13920 }
13921 if (obj2) {
13922 {
13923 arg3 = (bool)(SWIG_As_bool(obj2));
13924 if (SWIG_arg_fail(3)) SWIG_fail;
13925 }
13926 }
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 (arg1)->SetDefaultRowSize(arg2,arg3);
13930
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 Py_INCREF(Py_None); resultobj = Py_None;
13935 return resultobj;
13936 fail:
13937 return NULL;
13938 }
13939
13940
13941 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13942 PyObject *resultobj;
13943 wxGrid *arg1 = (wxGrid *) 0 ;
13944 int arg2 ;
13945 int arg3 ;
13946 PyObject * obj0 = 0 ;
13947 PyObject * obj1 = 0 ;
13948 PyObject * obj2 = 0 ;
13949 char *kwnames[] = {
13950 (char *) "self",(char *) "row",(char *) "height", NULL
13951 };
13952
13953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(1)) SWIG_fail;
13956 {
13957 arg2 = (int)(SWIG_As_int(obj1));
13958 if (SWIG_arg_fail(2)) SWIG_fail;
13959 }
13960 {
13961 arg3 = (int)(SWIG_As_int(obj2));
13962 if (SWIG_arg_fail(3)) SWIG_fail;
13963 }
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 (arg1)->SetRowSize(arg2,arg3);
13967
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 Py_INCREF(Py_None); resultobj = Py_None;
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj;
13980 wxGrid *arg1 = (wxGrid *) 0 ;
13981 int arg2 ;
13982 bool arg3 = (bool) false ;
13983 PyObject * obj0 = 0 ;
13984 PyObject * obj1 = 0 ;
13985 PyObject * obj2 = 0 ;
13986 char *kwnames[] = {
13987 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
13988 };
13989
13990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13992 if (SWIG_arg_fail(1)) SWIG_fail;
13993 {
13994 arg2 = (int)(SWIG_As_int(obj1));
13995 if (SWIG_arg_fail(2)) SWIG_fail;
13996 }
13997 if (obj2) {
13998 {
13999 arg3 = (bool)(SWIG_As_bool(obj2));
14000 if (SWIG_arg_fail(3)) SWIG_fail;
14001 }
14002 }
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 (arg1)->SetDefaultColSize(arg2,arg3);
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 Py_INCREF(Py_None); resultobj = Py_None;
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj;
14019 wxGrid *arg1 = (wxGrid *) 0 ;
14020 int arg2 ;
14021 int arg3 ;
14022 PyObject * obj0 = 0 ;
14023 PyObject * obj1 = 0 ;
14024 PyObject * obj2 = 0 ;
14025 char *kwnames[] = {
14026 (char *) "self",(char *) "col",(char *) "width", NULL
14027 };
14028
14029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14031 if (SWIG_arg_fail(1)) SWIG_fail;
14032 {
14033 arg2 = (int)(SWIG_As_int(obj1));
14034 if (SWIG_arg_fail(2)) SWIG_fail;
14035 }
14036 {
14037 arg3 = (int)(SWIG_As_int(obj2));
14038 if (SWIG_arg_fail(3)) SWIG_fail;
14039 }
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 (arg1)->SetColSize(arg2,arg3);
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 Py_INCREF(Py_None); resultobj = Py_None;
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14055 PyObject *resultobj;
14056 wxGrid *arg1 = (wxGrid *) 0 ;
14057 int arg2 ;
14058 bool arg3 = (bool) true ;
14059 PyObject * obj0 = 0 ;
14060 PyObject * obj1 = 0 ;
14061 PyObject * obj2 = 0 ;
14062 char *kwnames[] = {
14063 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14064 };
14065
14066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14068 if (SWIG_arg_fail(1)) SWIG_fail;
14069 {
14070 arg2 = (int)(SWIG_As_int(obj1));
14071 if (SWIG_arg_fail(2)) SWIG_fail;
14072 }
14073 if (obj2) {
14074 {
14075 arg3 = (bool)(SWIG_As_bool(obj2));
14076 if (SWIG_arg_fail(3)) SWIG_fail;
14077 }
14078 }
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 (arg1)->AutoSizeColumn(arg2,arg3);
14082
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 Py_INCREF(Py_None); resultobj = Py_None;
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj;
14095 wxGrid *arg1 = (wxGrid *) 0 ;
14096 int arg2 ;
14097 bool arg3 = (bool) true ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 {
14109 arg2 = (int)(SWIG_As_int(obj1));
14110 if (SWIG_arg_fail(2)) SWIG_fail;
14111 }
14112 if (obj2) {
14113 {
14114 arg3 = (bool)(SWIG_As_bool(obj2));
14115 if (SWIG_arg_fail(3)) SWIG_fail;
14116 }
14117 }
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->AutoSizeRow(arg2,arg3);
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 Py_INCREF(Py_None); resultobj = Py_None;
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj;
14134 wxGrid *arg1 = (wxGrid *) 0 ;
14135 bool arg2 = (bool) true ;
14136 PyObject * obj0 = 0 ;
14137 PyObject * obj1 = 0 ;
14138 char *kwnames[] = {
14139 (char *) "self",(char *) "setAsMin", NULL
14140 };
14141
14142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14144 if (SWIG_arg_fail(1)) SWIG_fail;
14145 if (obj1) {
14146 {
14147 arg2 = (bool)(SWIG_As_bool(obj1));
14148 if (SWIG_arg_fail(2)) SWIG_fail;
14149 }
14150 }
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 (arg1)->AutoSizeColumns(arg2);
14154
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 Py_INCREF(Py_None); resultobj = Py_None;
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14166 PyObject *resultobj;
14167 wxGrid *arg1 = (wxGrid *) 0 ;
14168 bool arg2 = (bool) true ;
14169 PyObject * obj0 = 0 ;
14170 PyObject * obj1 = 0 ;
14171 char *kwnames[] = {
14172 (char *) "self",(char *) "setAsMin", NULL
14173 };
14174
14175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14177 if (SWIG_arg_fail(1)) SWIG_fail;
14178 if (obj1) {
14179 {
14180 arg2 = (bool)(SWIG_As_bool(obj1));
14181 if (SWIG_arg_fail(2)) SWIG_fail;
14182 }
14183 }
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 (arg1)->AutoSizeRows(arg2);
14187
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 Py_INCREF(Py_None); resultobj = Py_None;
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj;
14200 wxGrid *arg1 = (wxGrid *) 0 ;
14201 PyObject * obj0 = 0 ;
14202 char *kwnames[] = {
14203 (char *) "self", NULL
14204 };
14205
14206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) goto fail;
14207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14208 if (SWIG_arg_fail(1)) SWIG_fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 (arg1)->AutoSize();
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 Py_INCREF(Py_None); resultobj = Py_None;
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxGrid *arg1 = (wxGrid *) 0 ;
14226 int arg2 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 char *kwnames[] = {
14230 (char *) "self",(char *) "row", NULL
14231 };
14232
14233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 {
14237 arg2 = (int)(SWIG_As_int(obj1));
14238 if (SWIG_arg_fail(2)) SWIG_fail;
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 (arg1)->AutoSizeRowLabelSize(arg2);
14243
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 Py_INCREF(Py_None); resultobj = Py_None;
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxGrid *arg1 = (wxGrid *) 0 ;
14257 int arg2 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "col", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 arg2 = (int)(SWIG_As_int(obj1));
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->AutoSizeColLabelSize(arg2);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 Py_INCREF(Py_None); resultobj = Py_None;
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj;
14287 wxGrid *arg1 = (wxGrid *) 0 ;
14288 int arg2 ;
14289 int arg3 ;
14290 PyObject * obj0 = 0 ;
14291 PyObject * obj1 = 0 ;
14292 PyObject * obj2 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "col",(char *) "width", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 arg2 = (int)(SWIG_As_int(obj1));
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 }
14304 {
14305 arg3 = (int)(SWIG_As_int(obj2));
14306 if (SWIG_arg_fail(3)) SWIG_fail;
14307 }
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 (arg1)->SetColMinimalWidth(arg2,arg3);
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 Py_INCREF(Py_None); resultobj = Py_None;
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj;
14324 wxGrid *arg1 = (wxGrid *) 0 ;
14325 int arg2 ;
14326 int arg3 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 PyObject * obj2 = 0 ;
14330 char *kwnames[] = {
14331 (char *) "self",(char *) "row",(char *) "width", NULL
14332 };
14333
14334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14336 if (SWIG_arg_fail(1)) SWIG_fail;
14337 {
14338 arg2 = (int)(SWIG_As_int(obj1));
14339 if (SWIG_arg_fail(2)) SWIG_fail;
14340 }
14341 {
14342 arg3 = (int)(SWIG_As_int(obj2));
14343 if (SWIG_arg_fail(3)) SWIG_fail;
14344 }
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 (arg1)->SetRowMinimalHeight(arg2,arg3);
14348
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 Py_INCREF(Py_None); resultobj = Py_None;
14353 return resultobj;
14354 fail:
14355 return NULL;
14356 }
14357
14358
14359 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14360 PyObject *resultobj;
14361 wxGrid *arg1 = (wxGrid *) 0 ;
14362 int arg2 ;
14363 PyObject * obj0 = 0 ;
14364 PyObject * obj1 = 0 ;
14365 char *kwnames[] = {
14366 (char *) "self",(char *) "width", NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14371 if (SWIG_arg_fail(1)) SWIG_fail;
14372 {
14373 arg2 = (int)(SWIG_As_int(obj1));
14374 if (SWIG_arg_fail(2)) SWIG_fail;
14375 }
14376 {
14377 PyThreadState* __tstate = wxPyBeginAllowThreads();
14378 (arg1)->SetColMinimalAcceptableWidth(arg2);
14379
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 Py_INCREF(Py_None); resultobj = Py_None;
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj;
14392 wxGrid *arg1 = (wxGrid *) 0 ;
14393 int arg2 ;
14394 PyObject * obj0 = 0 ;
14395 PyObject * obj1 = 0 ;
14396 char *kwnames[] = {
14397 (char *) "self",(char *) "width", NULL
14398 };
14399
14400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14402 if (SWIG_arg_fail(1)) SWIG_fail;
14403 {
14404 arg2 = (int)(SWIG_As_int(obj1));
14405 if (SWIG_arg_fail(2)) SWIG_fail;
14406 }
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14410
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 Py_INCREF(Py_None); resultobj = Py_None;
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj;
14423 wxGrid *arg1 = (wxGrid *) 0 ;
14424 int result;
14425 PyObject * obj0 = 0 ;
14426 char *kwnames[] = {
14427 (char *) "self", NULL
14428 };
14429
14430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14432 if (SWIG_arg_fail(1)) SWIG_fail;
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14436
14437 wxPyEndAllowThreads(__tstate);
14438 if (PyErr_Occurred()) SWIG_fail;
14439 }
14440 {
14441 resultobj = SWIG_From_int((int)(result));
14442 }
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxGrid *arg1 = (wxGrid *) 0 ;
14452 int result;
14453 PyObject * obj0 = 0 ;
14454 char *kwnames[] = {
14455 (char *) "self", NULL
14456 };
14457
14458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14460 if (SWIG_arg_fail(1)) SWIG_fail;
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 {
14469 resultobj = SWIG_From_int((int)(result));
14470 }
14471 return resultobj;
14472 fail:
14473 return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14478 PyObject *resultobj;
14479 wxGrid *arg1 = (wxGrid *) 0 ;
14480 wxColour *arg2 = 0 ;
14481 wxColour temp2 ;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self","arg2", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 arg2 = &temp2;
14493 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14494 }
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 Py_INCREF(Py_None); resultobj = Py_None;
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj;
14511 wxGrid *arg1 = (wxGrid *) 0 ;
14512 int arg2 ;
14513 int arg3 ;
14514 wxColour *arg4 = 0 ;
14515 wxColour temp4 ;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 PyObject * obj2 = 0 ;
14519 PyObject * obj3 = 0 ;
14520 char *kwnames[] = {
14521 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14522 };
14523
14524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14526 if (SWIG_arg_fail(1)) SWIG_fail;
14527 {
14528 arg2 = (int)(SWIG_As_int(obj1));
14529 if (SWIG_arg_fail(2)) SWIG_fail;
14530 }
14531 {
14532 arg3 = (int)(SWIG_As_int(obj2));
14533 if (SWIG_arg_fail(3)) SWIG_fail;
14534 }
14535 {
14536 arg4 = &temp4;
14537 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 Py_INCREF(Py_None); resultobj = Py_None;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxGrid *arg1 = (wxGrid *) 0 ;
14556 wxColour *arg2 = 0 ;
14557 wxColour temp2 ;
14558 PyObject * obj0 = 0 ;
14559 PyObject * obj1 = 0 ;
14560 char *kwnames[] = {
14561 (char *) "self","arg2", NULL
14562 };
14563
14564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14566 if (SWIG_arg_fail(1)) SWIG_fail;
14567 {
14568 arg2 = &temp2;
14569 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14570 }
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14574
14575 wxPyEndAllowThreads(__tstate);
14576 if (PyErr_Occurred()) SWIG_fail;
14577 }
14578 Py_INCREF(Py_None); resultobj = Py_None;
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxGrid *arg1 = (wxGrid *) 0 ;
14588 int arg2 ;
14589 int arg3 ;
14590 wxColour *arg4 = 0 ;
14591 wxColour temp4 ;
14592 PyObject * obj0 = 0 ;
14593 PyObject * obj1 = 0 ;
14594 PyObject * obj2 = 0 ;
14595 PyObject * obj3 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 arg2 = (int)(SWIG_As_int(obj1));
14605 if (SWIG_arg_fail(2)) SWIG_fail;
14606 }
14607 {
14608 arg3 = (int)(SWIG_As_int(obj2));
14609 if (SWIG_arg_fail(3)) SWIG_fail;
14610 }
14611 {
14612 arg4 = &temp4;
14613 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14614 }
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14618
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 Py_INCREF(Py_None); resultobj = Py_None;
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14630 PyObject *resultobj;
14631 wxGrid *arg1 = (wxGrid *) 0 ;
14632 wxFont *arg2 = 0 ;
14633 PyObject * obj0 = 0 ;
14634 PyObject * obj1 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "self","arg2", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(1)) SWIG_fail;
14642 {
14643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(2)) SWIG_fail;
14645 if (arg2 == NULL) {
14646 SWIG_null_ref("wxFont");
14647 }
14648 if (SWIG_arg_fail(2)) SWIG_fail;
14649 }
14650 {
14651 PyThreadState* __tstate = wxPyBeginAllowThreads();
14652 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14653
14654 wxPyEndAllowThreads(__tstate);
14655 if (PyErr_Occurred()) SWIG_fail;
14656 }
14657 Py_INCREF(Py_None); resultobj = Py_None;
14658 return resultobj;
14659 fail:
14660 return NULL;
14661 }
14662
14663
14664 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14665 PyObject *resultobj;
14666 wxGrid *arg1 = (wxGrid *) 0 ;
14667 int arg2 ;
14668 int arg3 ;
14669 wxFont *arg4 = 0 ;
14670 PyObject * obj0 = 0 ;
14671 PyObject * obj1 = 0 ;
14672 PyObject * obj2 = 0 ;
14673 PyObject * obj3 = 0 ;
14674 char *kwnames[] = {
14675 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14676 };
14677
14678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14680 if (SWIG_arg_fail(1)) SWIG_fail;
14681 {
14682 arg2 = (int)(SWIG_As_int(obj1));
14683 if (SWIG_arg_fail(2)) SWIG_fail;
14684 }
14685 {
14686 arg3 = (int)(SWIG_As_int(obj2));
14687 if (SWIG_arg_fail(3)) SWIG_fail;
14688 }
14689 {
14690 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14691 if (SWIG_arg_fail(4)) SWIG_fail;
14692 if (arg4 == NULL) {
14693 SWIG_null_ref("wxFont");
14694 }
14695 if (SWIG_arg_fail(4)) SWIG_fail;
14696 }
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
14700
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 Py_INCREF(Py_None); resultobj = Py_None;
14705 return resultobj;
14706 fail:
14707 return NULL;
14708 }
14709
14710
14711 static PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14712 PyObject *resultobj;
14713 wxGrid *arg1 = (wxGrid *) 0 ;
14714 int arg2 ;
14715 int arg3 ;
14716 PyObject * obj0 = 0 ;
14717 PyObject * obj1 = 0 ;
14718 PyObject * obj2 = 0 ;
14719 char *kwnames[] = {
14720 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14721 };
14722
14723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14725 if (SWIG_arg_fail(1)) SWIG_fail;
14726 {
14727 arg2 = (int)(SWIG_As_int(obj1));
14728 if (SWIG_arg_fail(2)) SWIG_fail;
14729 }
14730 {
14731 arg3 = (int)(SWIG_As_int(obj2));
14732 if (SWIG_arg_fail(3)) SWIG_fail;
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14737
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 Py_INCREF(Py_None); resultobj = Py_None;
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj;
14750 wxGrid *arg1 = (wxGrid *) 0 ;
14751 int arg2 ;
14752 int arg3 ;
14753 int arg4 ;
14754 int arg5 ;
14755 PyObject * obj0 = 0 ;
14756 PyObject * obj1 = 0 ;
14757 PyObject * obj2 = 0 ;
14758 PyObject * obj3 = 0 ;
14759 PyObject * obj4 = 0 ;
14760 char *kwnames[] = {
14761 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14762 };
14763
14764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14766 if (SWIG_arg_fail(1)) SWIG_fail;
14767 {
14768 arg2 = (int)(SWIG_As_int(obj1));
14769 if (SWIG_arg_fail(2)) SWIG_fail;
14770 }
14771 {
14772 arg3 = (int)(SWIG_As_int(obj2));
14773 if (SWIG_arg_fail(3)) SWIG_fail;
14774 }
14775 {
14776 arg4 = (int)(SWIG_As_int(obj3));
14777 if (SWIG_arg_fail(4)) SWIG_fail;
14778 }
14779 {
14780 arg5 = (int)(SWIG_As_int(obj4));
14781 if (SWIG_arg_fail(5)) SWIG_fail;
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 Py_INCREF(Py_None); resultobj = Py_None;
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj;
14799 wxGrid *arg1 = (wxGrid *) 0 ;
14800 bool arg2 ;
14801 PyObject * obj0 = 0 ;
14802 PyObject * obj1 = 0 ;
14803 char *kwnames[] = {
14804 (char *) "self",(char *) "allow", NULL
14805 };
14806
14807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
14808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(1)) SWIG_fail;
14810 {
14811 arg2 = (bool)(SWIG_As_bool(obj1));
14812 if (SWIG_arg_fail(2)) SWIG_fail;
14813 }
14814 {
14815 PyThreadState* __tstate = wxPyBeginAllowThreads();
14816 (arg1)->SetDefaultCellOverflow(arg2);
14817
14818 wxPyEndAllowThreads(__tstate);
14819 if (PyErr_Occurred()) SWIG_fail;
14820 }
14821 Py_INCREF(Py_None); resultobj = Py_None;
14822 return resultobj;
14823 fail:
14824 return NULL;
14825 }
14826
14827
14828 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj;
14830 wxGrid *arg1 = (wxGrid *) 0 ;
14831 int arg2 ;
14832 int arg3 ;
14833 bool arg4 ;
14834 PyObject * obj0 = 0 ;
14835 PyObject * obj1 = 0 ;
14836 PyObject * obj2 = 0 ;
14837 PyObject * obj3 = 0 ;
14838 char *kwnames[] = {
14839 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
14840 };
14841
14842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 {
14846 arg2 = (int)(SWIG_As_int(obj1));
14847 if (SWIG_arg_fail(2)) SWIG_fail;
14848 }
14849 {
14850 arg3 = (int)(SWIG_As_int(obj2));
14851 if (SWIG_arg_fail(3)) SWIG_fail;
14852 }
14853 {
14854 arg4 = (bool)(SWIG_As_bool(obj3));
14855 if (SWIG_arg_fail(4)) SWIG_fail;
14856 }
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 (arg1)->SetCellOverflow(arg2,arg3,arg4);
14860
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 Py_INCREF(Py_None); resultobj = Py_None;
14865 return resultobj;
14866 fail:
14867 return NULL;
14868 }
14869
14870
14871 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj;
14873 wxGrid *arg1 = (wxGrid *) 0 ;
14874 int arg2 ;
14875 int arg3 ;
14876 int arg4 ;
14877 int arg5 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 PyObject * obj3 = 0 ;
14882 PyObject * obj4 = 0 ;
14883 char *kwnames[] = {
14884 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
14885 };
14886
14887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14889 if (SWIG_arg_fail(1)) SWIG_fail;
14890 {
14891 arg2 = (int)(SWIG_As_int(obj1));
14892 if (SWIG_arg_fail(2)) SWIG_fail;
14893 }
14894 {
14895 arg3 = (int)(SWIG_As_int(obj2));
14896 if (SWIG_arg_fail(3)) SWIG_fail;
14897 }
14898 {
14899 arg4 = (int)(SWIG_As_int(obj3));
14900 if (SWIG_arg_fail(4)) SWIG_fail;
14901 }
14902 {
14903 arg5 = (int)(SWIG_As_int(obj4));
14904 if (SWIG_arg_fail(5)) SWIG_fail;
14905 }
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
14909
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 Py_INCREF(Py_None); resultobj = Py_None;
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj;
14922 wxGrid *arg1 = (wxGrid *) 0 ;
14923 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
14924 PyObject * obj0 = 0 ;
14925 PyObject * obj1 = 0 ;
14926 char *kwnames[] = {
14927 (char *) "self",(char *) "renderer", NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
14931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14932 if (SWIG_arg_fail(1)) SWIG_fail;
14933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14934 if (SWIG_arg_fail(2)) SWIG_fail;
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 (arg1)->SetDefaultRenderer(arg2);
14938
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 Py_INCREF(Py_None); resultobj = Py_None;
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj;
14951 wxGrid *arg1 = (wxGrid *) 0 ;
14952 int arg2 ;
14953 int arg3 ;
14954 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
14955 PyObject * obj0 = 0 ;
14956 PyObject * obj1 = 0 ;
14957 PyObject * obj2 = 0 ;
14958 PyObject * obj3 = 0 ;
14959 char *kwnames[] = {
14960 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
14961 };
14962
14963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14965 if (SWIG_arg_fail(1)) SWIG_fail;
14966 {
14967 arg2 = (int)(SWIG_As_int(obj1));
14968 if (SWIG_arg_fail(2)) SWIG_fail;
14969 }
14970 {
14971 arg3 = (int)(SWIG_As_int(obj2));
14972 if (SWIG_arg_fail(3)) SWIG_fail;
14973 }
14974 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
14975 if (SWIG_arg_fail(4)) SWIG_fail;
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 (arg1)->SetCellRenderer(arg2,arg3,arg4);
14979
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 Py_INCREF(Py_None); resultobj = Py_None;
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj;
14992 wxGrid *arg1 = (wxGrid *) 0 ;
14993 wxGridCellRenderer *result;
14994 PyObject * obj0 = 0 ;
14995 char *kwnames[] = {
14996 (char *) "self", NULL
14997 };
14998
14999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
15000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15001 if (SWIG_arg_fail(1)) SWIG_fail;
15002 {
15003 PyThreadState* __tstate = wxPyBeginAllowThreads();
15004 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15005
15006 wxPyEndAllowThreads(__tstate);
15007 if (PyErr_Occurred()) SWIG_fail;
15008 }
15009 {
15010 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15011 }
15012 return resultobj;
15013 fail:
15014 return NULL;
15015 }
15016
15017
15018 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj;
15020 wxGrid *arg1 = (wxGrid *) 0 ;
15021 int arg2 ;
15022 int arg3 ;
15023 wxGridCellRenderer *result;
15024 PyObject * obj0 = 0 ;
15025 PyObject * obj1 = 0 ;
15026 PyObject * obj2 = 0 ;
15027 char *kwnames[] = {
15028 (char *) "self",(char *) "row",(char *) "col", NULL
15029 };
15030
15031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15033 if (SWIG_arg_fail(1)) SWIG_fail;
15034 {
15035 arg2 = (int)(SWIG_As_int(obj1));
15036 if (SWIG_arg_fail(2)) SWIG_fail;
15037 }
15038 {
15039 arg3 = (int)(SWIG_As_int(obj2));
15040 if (SWIG_arg_fail(3)) SWIG_fail;
15041 }
15042 {
15043 PyThreadState* __tstate = wxPyBeginAllowThreads();
15044 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15045
15046 wxPyEndAllowThreads(__tstate);
15047 if (PyErr_Occurred()) SWIG_fail;
15048 }
15049 {
15050 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
15051 }
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15059 PyObject *resultobj;
15060 wxGrid *arg1 = (wxGrid *) 0 ;
15061 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 char *kwnames[] = {
15065 (char *) "self",(char *) "editor", NULL
15066 };
15067
15068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15070 if (SWIG_arg_fail(1)) SWIG_fail;
15071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15072 if (SWIG_arg_fail(2)) SWIG_fail;
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 (arg1)->SetDefaultEditor(arg2);
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 Py_INCREF(Py_None); resultobj = Py_None;
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj;
15089 wxGrid *arg1 = (wxGrid *) 0 ;
15090 int arg2 ;
15091 int arg3 ;
15092 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 PyObject * obj2 = 0 ;
15096 PyObject * obj3 = 0 ;
15097 char *kwnames[] = {
15098 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15099 };
15100
15101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15103 if (SWIG_arg_fail(1)) SWIG_fail;
15104 {
15105 arg2 = (int)(SWIG_As_int(obj1));
15106 if (SWIG_arg_fail(2)) SWIG_fail;
15107 }
15108 {
15109 arg3 = (int)(SWIG_As_int(obj2));
15110 if (SWIG_arg_fail(3)) SWIG_fail;
15111 }
15112 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15113 if (SWIG_arg_fail(4)) SWIG_fail;
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 (arg1)->SetCellEditor(arg2,arg3,arg4);
15117
15118 wxPyEndAllowThreads(__tstate);
15119 if (PyErr_Occurred()) SWIG_fail;
15120 }
15121 Py_INCREF(Py_None); resultobj = Py_None;
15122 return resultobj;
15123 fail:
15124 return NULL;
15125 }
15126
15127
15128 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj;
15130 wxGrid *arg1 = (wxGrid *) 0 ;
15131 wxGridCellEditor *result;
15132 PyObject * obj0 = 0 ;
15133 char *kwnames[] = {
15134 (char *) "self", NULL
15135 };
15136
15137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15139 if (SWIG_arg_fail(1)) SWIG_fail;
15140 {
15141 PyThreadState* __tstate = wxPyBeginAllowThreads();
15142 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15143
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 {
15148 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15149 }
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15157 PyObject *resultobj;
15158 wxGrid *arg1 = (wxGrid *) 0 ;
15159 int arg2 ;
15160 int arg3 ;
15161 wxGridCellEditor *result;
15162 PyObject * obj0 = 0 ;
15163 PyObject * obj1 = 0 ;
15164 PyObject * obj2 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self",(char *) "row",(char *) "col", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 {
15173 arg2 = (int)(SWIG_As_int(obj1));
15174 if (SWIG_arg_fail(2)) SWIG_fail;
15175 }
15176 {
15177 arg3 = (int)(SWIG_As_int(obj2));
15178 if (SWIG_arg_fail(3)) SWIG_fail;
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15183
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 {
15188 resultobj = wxPyMake_wxGridCellEditor(result, 0);
15189 }
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj;
15198 wxGrid *arg1 = (wxGrid *) 0 ;
15199 int arg2 ;
15200 int arg3 ;
15201 wxString result;
15202 PyObject * obj0 = 0 ;
15203 PyObject * obj1 = 0 ;
15204 PyObject * obj2 = 0 ;
15205 char *kwnames[] = {
15206 (char *) "self",(char *) "row",(char *) "col", NULL
15207 };
15208
15209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15211 if (SWIG_arg_fail(1)) SWIG_fail;
15212 {
15213 arg2 = (int)(SWIG_As_int(obj1));
15214 if (SWIG_arg_fail(2)) SWIG_fail;
15215 }
15216 {
15217 arg3 = (int)(SWIG_As_int(obj2));
15218 if (SWIG_arg_fail(3)) SWIG_fail;
15219 }
15220 {
15221 PyThreadState* __tstate = wxPyBeginAllowThreads();
15222 result = (arg1)->GetCellValue(arg2,arg3);
15223
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 {
15228 #if wxUSE_UNICODE
15229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15230 #else
15231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15232 #endif
15233 }
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxGrid *arg1 = (wxGrid *) 0 ;
15243 int arg2 ;
15244 int arg3 ;
15245 wxString *arg4 = 0 ;
15246 bool temp4 = false ;
15247 PyObject * obj0 = 0 ;
15248 PyObject * obj1 = 0 ;
15249 PyObject * obj2 = 0 ;
15250 PyObject * obj3 = 0 ;
15251 char *kwnames[] = {
15252 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15257 if (SWIG_arg_fail(1)) SWIG_fail;
15258 {
15259 arg2 = (int)(SWIG_As_int(obj1));
15260 if (SWIG_arg_fail(2)) SWIG_fail;
15261 }
15262 {
15263 arg3 = (int)(SWIG_As_int(obj2));
15264 if (SWIG_arg_fail(3)) SWIG_fail;
15265 }
15266 {
15267 arg4 = wxString_in_helper(obj3);
15268 if (arg4 == NULL) SWIG_fail;
15269 temp4 = true;
15270 }
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15274
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 Py_INCREF(Py_None); resultobj = Py_None;
15279 {
15280 if (temp4)
15281 delete arg4;
15282 }
15283 return resultobj;
15284 fail:
15285 {
15286 if (temp4)
15287 delete arg4;
15288 }
15289 return NULL;
15290 }
15291
15292
15293 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15294 PyObject *resultobj;
15295 wxGrid *arg1 = (wxGrid *) 0 ;
15296 int arg2 ;
15297 int arg3 ;
15298 bool result;
15299 PyObject * obj0 = 0 ;
15300 PyObject * obj1 = 0 ;
15301 PyObject * obj2 = 0 ;
15302 char *kwnames[] = {
15303 (char *) "self",(char *) "row",(char *) "col", NULL
15304 };
15305
15306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15308 if (SWIG_arg_fail(1)) SWIG_fail;
15309 {
15310 arg2 = (int)(SWIG_As_int(obj1));
15311 if (SWIG_arg_fail(2)) SWIG_fail;
15312 }
15313 {
15314 arg3 = (int)(SWIG_As_int(obj2));
15315 if (SWIG_arg_fail(3)) SWIG_fail;
15316 }
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15320
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 {
15325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15326 }
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj;
15335 wxGrid *arg1 = (wxGrid *) 0 ;
15336 int arg2 ;
15337 int arg3 ;
15338 bool arg4 = (bool) true ;
15339 PyObject * obj0 = 0 ;
15340 PyObject * obj1 = 0 ;
15341 PyObject * obj2 = 0 ;
15342 PyObject * obj3 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 arg2 = (int)(SWIG_As_int(obj1));
15352 if (SWIG_arg_fail(2)) SWIG_fail;
15353 }
15354 {
15355 arg3 = (int)(SWIG_As_int(obj2));
15356 if (SWIG_arg_fail(3)) SWIG_fail;
15357 }
15358 if (obj3) {
15359 {
15360 arg4 = (bool)(SWIG_As_bool(obj3));
15361 if (SWIG_arg_fail(4)) SWIG_fail;
15362 }
15363 }
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 (arg1)->SetReadOnly(arg2,arg3,arg4);
15367
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 Py_INCREF(Py_None); resultobj = Py_None;
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj;
15380 wxGrid *arg1 = (wxGrid *) 0 ;
15381 int arg2 ;
15382 bool arg3 = (bool) false ;
15383 PyObject * obj0 = 0 ;
15384 PyObject * obj1 = 0 ;
15385 PyObject * obj2 = 0 ;
15386 char *kwnames[] = {
15387 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15388 };
15389
15390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15392 if (SWIG_arg_fail(1)) SWIG_fail;
15393 {
15394 arg2 = (int)(SWIG_As_int(obj1));
15395 if (SWIG_arg_fail(2)) SWIG_fail;
15396 }
15397 if (obj2) {
15398 {
15399 arg3 = (bool)(SWIG_As_bool(obj2));
15400 if (SWIG_arg_fail(3)) SWIG_fail;
15401 }
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 (arg1)->SelectRow(arg2,arg3);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 Py_INCREF(Py_None); resultobj = Py_None;
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxGrid *arg1 = (wxGrid *) 0 ;
15420 int arg2 ;
15421 bool arg3 = (bool) false ;
15422 PyObject * obj0 = 0 ;
15423 PyObject * obj1 = 0 ;
15424 PyObject * obj2 = 0 ;
15425 char *kwnames[] = {
15426 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15427 };
15428
15429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15431 if (SWIG_arg_fail(1)) SWIG_fail;
15432 {
15433 arg2 = (int)(SWIG_As_int(obj1));
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 }
15436 if (obj2) {
15437 {
15438 arg3 = (bool)(SWIG_As_bool(obj2));
15439 if (SWIG_arg_fail(3)) SWIG_fail;
15440 }
15441 }
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 (arg1)->SelectCol(arg2,arg3);
15445
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 Py_INCREF(Py_None); resultobj = Py_None;
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15457 PyObject *resultobj;
15458 wxGrid *arg1 = (wxGrid *) 0 ;
15459 int arg2 ;
15460 int arg3 ;
15461 int arg4 ;
15462 int arg5 ;
15463 bool arg6 = (bool) false ;
15464 PyObject * obj0 = 0 ;
15465 PyObject * obj1 = 0 ;
15466 PyObject * obj2 = 0 ;
15467 PyObject * obj3 = 0 ;
15468 PyObject * obj4 = 0 ;
15469 PyObject * obj5 = 0 ;
15470 char *kwnames[] = {
15471 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15472 };
15473
15474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15476 if (SWIG_arg_fail(1)) SWIG_fail;
15477 {
15478 arg2 = (int)(SWIG_As_int(obj1));
15479 if (SWIG_arg_fail(2)) SWIG_fail;
15480 }
15481 {
15482 arg3 = (int)(SWIG_As_int(obj2));
15483 if (SWIG_arg_fail(3)) SWIG_fail;
15484 }
15485 {
15486 arg4 = (int)(SWIG_As_int(obj3));
15487 if (SWIG_arg_fail(4)) SWIG_fail;
15488 }
15489 {
15490 arg5 = (int)(SWIG_As_int(obj4));
15491 if (SWIG_arg_fail(5)) SWIG_fail;
15492 }
15493 if (obj5) {
15494 {
15495 arg6 = (bool)(SWIG_As_bool(obj5));
15496 if (SWIG_arg_fail(6)) SWIG_fail;
15497 }
15498 }
15499 {
15500 PyThreadState* __tstate = wxPyBeginAllowThreads();
15501 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15502
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 Py_INCREF(Py_None); resultobj = Py_None;
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15514 PyObject *resultobj;
15515 wxGrid *arg1 = (wxGrid *) 0 ;
15516 PyObject * obj0 = 0 ;
15517 char *kwnames[] = {
15518 (char *) "self", NULL
15519 };
15520
15521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15523 if (SWIG_arg_fail(1)) SWIG_fail;
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 (arg1)->SelectAll();
15527
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 Py_INCREF(Py_None); resultobj = Py_None;
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj;
15540 wxGrid *arg1 = (wxGrid *) 0 ;
15541 bool result;
15542 PyObject * obj0 = 0 ;
15543 char *kwnames[] = {
15544 (char *) "self", NULL
15545 };
15546
15547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15549 if (SWIG_arg_fail(1)) SWIG_fail;
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = (bool)(arg1)->IsSelection();
15553
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 {
15558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15559 }
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxGrid *arg1 = (wxGrid *) 0 ;
15569 PyObject * obj0 = 0 ;
15570 char *kwnames[] = {
15571 (char *) "self", NULL
15572 };
15573
15574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15576 if (SWIG_arg_fail(1)) SWIG_fail;
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 (arg1)->ClearSelection();
15580
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 Py_INCREF(Py_None); resultobj = Py_None;
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj;
15593 wxGrid *arg1 = (wxGrid *) 0 ;
15594 int arg2 ;
15595 int arg3 ;
15596 bool result;
15597 PyObject * obj0 = 0 ;
15598 PyObject * obj1 = 0 ;
15599 PyObject * obj2 = 0 ;
15600 char *kwnames[] = {
15601 (char *) "self",(char *) "row",(char *) "col", NULL
15602 };
15603
15604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15606 if (SWIG_arg_fail(1)) SWIG_fail;
15607 {
15608 arg2 = (int)(SWIG_As_int(obj1));
15609 if (SWIG_arg_fail(2)) SWIG_fail;
15610 }
15611 {
15612 arg3 = (int)(SWIG_As_int(obj2));
15613 if (SWIG_arg_fail(3)) SWIG_fail;
15614 }
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15618
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 {
15623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15624 }
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15632 PyObject *resultobj;
15633 wxGrid *arg1 = (wxGrid *) 0 ;
15634 wxGridCellCoordsArray result;
15635 PyObject * obj0 = 0 ;
15636 char *kwnames[] = {
15637 (char *) "self", NULL
15638 };
15639
15640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15642 if (SWIG_arg_fail(1)) SWIG_fail;
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = ((wxGrid const *)arg1)->GetSelectedCells();
15646
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 {
15651 resultobj = wxGridCellCoordsArray_helper(result);
15652 }
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15660 PyObject *resultobj;
15661 wxGrid *arg1 = (wxGrid *) 0 ;
15662 wxGridCellCoordsArray result;
15663 PyObject * obj0 = 0 ;
15664 char *kwnames[] = {
15665 (char *) "self", NULL
15666 };
15667
15668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) goto fail;
15669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15670 if (SWIG_arg_fail(1)) SWIG_fail;
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15674
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 {
15679 resultobj = wxGridCellCoordsArray_helper(result);
15680 }
15681 return resultobj;
15682 fail:
15683 return NULL;
15684 }
15685
15686
15687 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15688 PyObject *resultobj;
15689 wxGrid *arg1 = (wxGrid *) 0 ;
15690 wxGridCellCoordsArray result;
15691 PyObject * obj0 = 0 ;
15692 char *kwnames[] = {
15693 (char *) "self", NULL
15694 };
15695
15696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15698 if (SWIG_arg_fail(1)) SWIG_fail;
15699 {
15700 PyThreadState* __tstate = wxPyBeginAllowThreads();
15701 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15702
15703 wxPyEndAllowThreads(__tstate);
15704 if (PyErr_Occurred()) SWIG_fail;
15705 }
15706 {
15707 resultobj = wxGridCellCoordsArray_helper(result);
15708 }
15709 return resultobj;
15710 fail:
15711 return NULL;
15712 }
15713
15714
15715 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15716 PyObject *resultobj;
15717 wxGrid *arg1 = (wxGrid *) 0 ;
15718 wxArrayInt result;
15719 PyObject * obj0 = 0 ;
15720 char *kwnames[] = {
15721 (char *) "self", NULL
15722 };
15723
15724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15726 if (SWIG_arg_fail(1)) SWIG_fail;
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = ((wxGrid const *)arg1)->GetSelectedRows();
15730
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 {
15735 resultobj = PyList_New(0);
15736 size_t idx;
15737 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15738 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15739 PyList_Append(resultobj, val);
15740 Py_DECREF(val);
15741 }
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj;
15751 wxGrid *arg1 = (wxGrid *) 0 ;
15752 wxArrayInt result;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = ((wxGrid const *)arg1)->GetSelectedCols();
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 {
15769 resultobj = PyList_New(0);
15770 size_t idx;
15771 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15772 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15773 PyList_Append(resultobj, val);
15774 Py_DECREF(val);
15775 }
15776 }
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15784 PyObject *resultobj;
15785 wxGrid *arg1 = (wxGrid *) 0 ;
15786 int arg2 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 char *kwnames[] = {
15790 (char *) "self",(char *) "row", NULL
15791 };
15792
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
15794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15795 if (SWIG_arg_fail(1)) SWIG_fail;
15796 {
15797 arg2 = (int)(SWIG_As_int(obj1));
15798 if (SWIG_arg_fail(2)) SWIG_fail;
15799 }
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 (arg1)->DeselectRow(arg2);
15803
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 Py_INCREF(Py_None); resultobj = Py_None;
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj;
15816 wxGrid *arg1 = (wxGrid *) 0 ;
15817 int arg2 ;
15818 PyObject * obj0 = 0 ;
15819 PyObject * obj1 = 0 ;
15820 char *kwnames[] = {
15821 (char *) "self",(char *) "col", NULL
15822 };
15823
15824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
15825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15826 if (SWIG_arg_fail(1)) SWIG_fail;
15827 {
15828 arg2 = (int)(SWIG_As_int(obj1));
15829 if (SWIG_arg_fail(2)) SWIG_fail;
15830 }
15831 {
15832 PyThreadState* __tstate = wxPyBeginAllowThreads();
15833 (arg1)->DeselectCol(arg2);
15834
15835 wxPyEndAllowThreads(__tstate);
15836 if (PyErr_Occurred()) SWIG_fail;
15837 }
15838 Py_INCREF(Py_None); resultobj = Py_None;
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj;
15847 wxGrid *arg1 = (wxGrid *) 0 ;
15848 int arg2 ;
15849 int arg3 ;
15850 PyObject * obj0 = 0 ;
15851 PyObject * obj1 = 0 ;
15852 PyObject * obj2 = 0 ;
15853 char *kwnames[] = {
15854 (char *) "self",(char *) "row",(char *) "col", NULL
15855 };
15856
15857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
15858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(1)) SWIG_fail;
15860 {
15861 arg2 = (int)(SWIG_As_int(obj1));
15862 if (SWIG_arg_fail(2)) SWIG_fail;
15863 }
15864 {
15865 arg3 = (int)(SWIG_As_int(obj2));
15866 if (SWIG_arg_fail(3)) SWIG_fail;
15867 }
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 (arg1)->DeselectCell(arg2,arg3);
15871
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 Py_INCREF(Py_None); resultobj = Py_None;
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
15883 PyObject *resultobj;
15884 wxGrid *arg1 = (wxGrid *) 0 ;
15885 wxGridCellCoords *arg2 = 0 ;
15886 wxGridCellCoords *arg3 = 0 ;
15887 wxRect result;
15888 wxGridCellCoords temp2 ;
15889 wxGridCellCoords temp3 ;
15890 PyObject * obj0 = 0 ;
15891 PyObject * obj1 = 0 ;
15892 PyObject * obj2 = 0 ;
15893 char *kwnames[] = {
15894 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
15895 };
15896
15897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
15898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15899 if (SWIG_arg_fail(1)) SWIG_fail;
15900 {
15901 arg2 = &temp2;
15902 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
15903 }
15904 {
15905 arg3 = &temp3;
15906 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
15907 }
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
15911
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 {
15916 wxRect * resultptr;
15917 resultptr = new wxRect((wxRect &)(result));
15918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15919 }
15920 return resultobj;
15921 fail:
15922 return NULL;
15923 }
15924
15925
15926 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15927 PyObject *resultobj;
15928 wxGrid *arg1 = (wxGrid *) 0 ;
15929 wxColour result;
15930 PyObject * obj0 = 0 ;
15931 char *kwnames[] = {
15932 (char *) "self", NULL
15933 };
15934
15935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
15936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15937 if (SWIG_arg_fail(1)) SWIG_fail;
15938 {
15939 PyThreadState* __tstate = wxPyBeginAllowThreads();
15940 result = ((wxGrid const *)arg1)->GetSelectionBackground();
15941
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 {
15946 wxColour * resultptr;
15947 resultptr = new wxColour((wxColour &)(result));
15948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15949 }
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15957 PyObject *resultobj;
15958 wxGrid *arg1 = (wxGrid *) 0 ;
15959 wxColour result;
15960 PyObject * obj0 = 0 ;
15961 char *kwnames[] = {
15962 (char *) "self", NULL
15963 };
15964
15965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
15966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15967 if (SWIG_arg_fail(1)) SWIG_fail;
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = ((wxGrid const *)arg1)->GetSelectionForeground();
15971
15972 wxPyEndAllowThreads(__tstate);
15973 if (PyErr_Occurred()) SWIG_fail;
15974 }
15975 {
15976 wxColour * resultptr;
15977 resultptr = new wxColour((wxColour &)(result));
15978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15979 }
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj;
15988 wxGrid *arg1 = (wxGrid *) 0 ;
15989 wxColour *arg2 = 0 ;
15990 wxColour temp2 ;
15991 PyObject * obj0 = 0 ;
15992 PyObject * obj1 = 0 ;
15993 char *kwnames[] = {
15994 (char *) "self",(char *) "c", NULL
15995 };
15996
15997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
15998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15999 if (SWIG_arg_fail(1)) SWIG_fail;
16000 {
16001 arg2 = &temp2;
16002 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16003 }
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16007
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 Py_INCREF(Py_None); resultobj = Py_None;
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj;
16020 wxGrid *arg1 = (wxGrid *) 0 ;
16021 wxColour *arg2 = 0 ;
16022 wxColour temp2 ;
16023 PyObject * obj0 = 0 ;
16024 PyObject * obj1 = 0 ;
16025 char *kwnames[] = {
16026 (char *) "self",(char *) "c", NULL
16027 };
16028
16029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) goto fail;
16030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16031 if (SWIG_arg_fail(1)) SWIG_fail;
16032 {
16033 arg2 = &temp2;
16034 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16035 }
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16039
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 Py_INCREF(Py_None); resultobj = Py_None;
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj;
16052 wxGrid *arg1 = (wxGrid *) 0 ;
16053 wxString *arg2 = 0 ;
16054 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16055 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16056 bool temp2 = false ;
16057 PyObject * obj0 = 0 ;
16058 PyObject * obj1 = 0 ;
16059 PyObject * obj2 = 0 ;
16060 PyObject * obj3 = 0 ;
16061 char *kwnames[] = {
16062 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16063 };
16064
16065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16067 if (SWIG_arg_fail(1)) SWIG_fail;
16068 {
16069 arg2 = wxString_in_helper(obj1);
16070 if (arg2 == NULL) SWIG_fail;
16071 temp2 = true;
16072 }
16073 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16074 if (SWIG_arg_fail(3)) SWIG_fail;
16075 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16076 if (SWIG_arg_fail(4)) SWIG_fail;
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16080
16081 wxPyEndAllowThreads(__tstate);
16082 if (PyErr_Occurred()) SWIG_fail;
16083 }
16084 Py_INCREF(Py_None); resultobj = Py_None;
16085 {
16086 if (temp2)
16087 delete arg2;
16088 }
16089 return resultobj;
16090 fail:
16091 {
16092 if (temp2)
16093 delete arg2;
16094 }
16095 return NULL;
16096 }
16097
16098
16099 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj;
16101 wxGrid *arg1 = (wxGrid *) 0 ;
16102 int arg2 ;
16103 int arg3 ;
16104 wxGridCellEditor *result;
16105 PyObject * obj0 = 0 ;
16106 PyObject * obj1 = 0 ;
16107 PyObject * obj2 = 0 ;
16108 char *kwnames[] = {
16109 (char *) "self",(char *) "row",(char *) "col", NULL
16110 };
16111
16112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16114 if (SWIG_arg_fail(1)) SWIG_fail;
16115 {
16116 arg2 = (int)(SWIG_As_int(obj1));
16117 if (SWIG_arg_fail(2)) SWIG_fail;
16118 }
16119 {
16120 arg3 = (int)(SWIG_As_int(obj2));
16121 if (SWIG_arg_fail(3)) SWIG_fail;
16122 }
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16126
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj;
16141 wxGrid *arg1 = (wxGrid *) 0 ;
16142 int arg2 ;
16143 int arg3 ;
16144 wxGridCellRenderer *result;
16145 PyObject * obj0 = 0 ;
16146 PyObject * obj1 = 0 ;
16147 PyObject * obj2 = 0 ;
16148 char *kwnames[] = {
16149 (char *) "self",(char *) "row",(char *) "col", NULL
16150 };
16151
16152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16154 if (SWIG_arg_fail(1)) SWIG_fail;
16155 {
16156 arg2 = (int)(SWIG_As_int(obj1));
16157 if (SWIG_arg_fail(2)) SWIG_fail;
16158 }
16159 {
16160 arg3 = (int)(SWIG_As_int(obj2));
16161 if (SWIG_arg_fail(3)) SWIG_fail;
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16166
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 {
16171 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16172 }
16173 return resultobj;
16174 fail:
16175 return NULL;
16176 }
16177
16178
16179 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj;
16181 wxGrid *arg1 = (wxGrid *) 0 ;
16182 wxString *arg2 = 0 ;
16183 wxGridCellEditor *result;
16184 bool temp2 = false ;
16185 PyObject * obj0 = 0 ;
16186 PyObject * obj1 = 0 ;
16187 char *kwnames[] = {
16188 (char *) "self",(char *) "typeName", NULL
16189 };
16190
16191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16193 if (SWIG_arg_fail(1)) SWIG_fail;
16194 {
16195 arg2 = wxString_in_helper(obj1);
16196 if (arg2 == NULL) SWIG_fail;
16197 temp2 = true;
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16202
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 {
16207 resultobj = wxPyMake_wxGridCellEditor(result, 0);
16208 }
16209 {
16210 if (temp2)
16211 delete arg2;
16212 }
16213 return resultobj;
16214 fail:
16215 {
16216 if (temp2)
16217 delete arg2;
16218 }
16219 return NULL;
16220 }
16221
16222
16223 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj;
16225 wxGrid *arg1 = (wxGrid *) 0 ;
16226 wxString *arg2 = 0 ;
16227 wxGridCellRenderer *result;
16228 bool temp2 = false ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 char *kwnames[] = {
16232 (char *) "self",(char *) "typeName", NULL
16233 };
16234
16235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16237 if (SWIG_arg_fail(1)) SWIG_fail;
16238 {
16239 arg2 = wxString_in_helper(obj1);
16240 if (arg2 == NULL) SWIG_fail;
16241 temp2 = true;
16242 }
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16246
16247 wxPyEndAllowThreads(__tstate);
16248 if (PyErr_Occurred()) SWIG_fail;
16249 }
16250 {
16251 resultobj = wxPyMake_wxGridCellRenderer(result, 0);
16252 }
16253 {
16254 if (temp2)
16255 delete arg2;
16256 }
16257 return resultobj;
16258 fail:
16259 {
16260 if (temp2)
16261 delete arg2;
16262 }
16263 return NULL;
16264 }
16265
16266
16267 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16268 PyObject *resultobj;
16269 wxGrid *arg1 = (wxGrid *) 0 ;
16270 int arg2 ;
16271 int arg3 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 PyObject * obj2 = 0 ;
16275 char *kwnames[] = {
16276 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16277 };
16278
16279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16281 if (SWIG_arg_fail(1)) SWIG_fail;
16282 {
16283 arg2 = (int)(SWIG_As_int(obj1));
16284 if (SWIG_arg_fail(2)) SWIG_fail;
16285 }
16286 {
16287 arg3 = (int)(SWIG_As_int(obj2));
16288 if (SWIG_arg_fail(3)) SWIG_fail;
16289 }
16290 {
16291 PyThreadState* __tstate = wxPyBeginAllowThreads();
16292 (arg1)->SetMargins(arg2,arg3);
16293
16294 wxPyEndAllowThreads(__tstate);
16295 if (PyErr_Occurred()) SWIG_fail;
16296 }
16297 Py_INCREF(Py_None); resultobj = Py_None;
16298 return resultobj;
16299 fail:
16300 return NULL;
16301 }
16302
16303
16304 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16305 PyObject *resultobj;
16306 wxGrid *arg1 = (wxGrid *) 0 ;
16307 wxWindow *result;
16308 PyObject * obj0 = 0 ;
16309 char *kwnames[] = {
16310 (char *) "self", NULL
16311 };
16312
16313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16315 if (SWIG_arg_fail(1)) SWIG_fail;
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (wxWindow *)(arg1)->GetGridWindow();
16319
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = wxPyMake_wxObject(result, 0);
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj;
16334 wxGrid *arg1 = (wxGrid *) 0 ;
16335 wxWindow *result;
16336 PyObject * obj0 = 0 ;
16337 char *kwnames[] = {
16338 (char *) "self", NULL
16339 };
16340
16341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16343 if (SWIG_arg_fail(1)) SWIG_fail;
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16347
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 {
16352 resultobj = wxPyMake_wxObject(result, 0);
16353 }
16354 return resultobj;
16355 fail:
16356 return NULL;
16357 }
16358
16359
16360 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16361 PyObject *resultobj;
16362 wxGrid *arg1 = (wxGrid *) 0 ;
16363 wxWindow *result;
16364 PyObject * obj0 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16375
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 {
16380 resultobj = wxPyMake_wxObject(result, 0);
16381 }
16382 return resultobj;
16383 fail:
16384 return NULL;
16385 }
16386
16387
16388 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16389 PyObject *resultobj;
16390 wxGrid *arg1 = (wxGrid *) 0 ;
16391 wxWindow *result;
16392 PyObject * obj0 = 0 ;
16393 char *kwnames[] = {
16394 (char *) "self", NULL
16395 };
16396
16397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16399 if (SWIG_arg_fail(1)) SWIG_fail;
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16403
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 {
16408 resultobj = wxPyMake_wxObject(result, 0);
16409 }
16410 return resultobj;
16411 fail:
16412 return NULL;
16413 }
16414
16415
16416 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16417 PyObject *resultobj;
16418 wxGrid *arg1 = (wxGrid *) 0 ;
16419 int arg2 ;
16420 PyObject * obj0 = 0 ;
16421 PyObject * obj1 = 0 ;
16422 char *kwnames[] = {
16423 (char *) "self",(char *) "x", NULL
16424 };
16425
16426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16428 if (SWIG_arg_fail(1)) SWIG_fail;
16429 {
16430 arg2 = (int)(SWIG_As_int(obj1));
16431 if (SWIG_arg_fail(2)) SWIG_fail;
16432 }
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 (arg1)->SetScrollLineX(arg2);
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 Py_INCREF(Py_None); resultobj = Py_None;
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 wxGrid *arg1 = (wxGrid *) 0 ;
16450 int arg2 ;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 char *kwnames[] = {
16454 (char *) "self",(char *) "y", NULL
16455 };
16456
16457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16459 if (SWIG_arg_fail(1)) SWIG_fail;
16460 {
16461 arg2 = (int)(SWIG_As_int(obj1));
16462 if (SWIG_arg_fail(2)) SWIG_fail;
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 (arg1)->SetScrollLineY(arg2);
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 Py_INCREF(Py_None); resultobj = Py_None;
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj;
16480 wxGrid *arg1 = (wxGrid *) 0 ;
16481 int result;
16482 PyObject * obj0 = 0 ;
16483 char *kwnames[] = {
16484 (char *) "self", NULL
16485 };
16486
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16489 if (SWIG_arg_fail(1)) SWIG_fail;
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16493
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 {
16498 resultobj = SWIG_From_int((int)(result));
16499 }
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj;
16508 wxGrid *arg1 = (wxGrid *) 0 ;
16509 int result;
16510 PyObject * obj0 = 0 ;
16511 char *kwnames[] = {
16512 (char *) "self", NULL
16513 };
16514
16515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16517 if (SWIG_arg_fail(1)) SWIG_fail;
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16521
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 {
16526 resultobj = SWIG_From_int((int)(result));
16527 }
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 wxGrid *arg1 = (wxGrid *) 0 ;
16537 int arg2 ;
16538 int result;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 char *kwnames[] = {
16542 (char *) "self",(char *) "x", NULL
16543 };
16544
16545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16547 if (SWIG_arg_fail(1)) SWIG_fail;
16548 {
16549 arg2 = (int)(SWIG_As_int(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16555
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 {
16560 resultobj = SWIG_From_int((int)(result));
16561 }
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxGrid *arg1 = (wxGrid *) 0 ;
16571 int arg2 ;
16572 int result;
16573 PyObject * obj0 = 0 ;
16574 PyObject * obj1 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self",(char *) "y", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 arg2 = (int)(SWIG_As_int(obj1));
16584 if (SWIG_arg_fail(2)) SWIG_fail;
16585 }
16586 {
16587 PyThreadState* __tstate = wxPyBeginAllowThreads();
16588 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16589
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 {
16594 resultobj = SWIG_From_int((int)(result));
16595 }
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16603 PyObject *resultobj;
16604 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16605 wxVisualAttributes result;
16606 PyObject * obj0 = 0 ;
16607 char *kwnames[] = {
16608 (char *) "variant", NULL
16609 };
16610
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16612 if (obj0) {
16613 {
16614 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16615 if (SWIG_arg_fail(1)) SWIG_fail;
16616 }
16617 }
16618 {
16619 if (!wxPyCheckForApp()) SWIG_fail;
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 result = wxGrid::GetClassDefaultAttributes((wxWindowVariant )arg1);
16622
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 {
16627 wxVisualAttributes * resultptr;
16628 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16630 }
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16638 PyObject *obj;
16639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16640 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16641 Py_INCREF(obj);
16642 return Py_BuildValue((char *)"");
16643 }
16644 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj;
16646 int arg1 ;
16647 wxEventType arg2 ;
16648 wxGrid *arg3 = (wxGrid *) 0 ;
16649 int arg4 = (int) -1 ;
16650 int arg5 = (int) -1 ;
16651 int arg6 = (int) -1 ;
16652 int arg7 = (int) -1 ;
16653 bool arg8 = (bool) true ;
16654 bool arg9 = (bool) false ;
16655 bool arg10 = (bool) false ;
16656 bool arg11 = (bool) false ;
16657 bool arg12 = (bool) false ;
16658 wxGridEvent *result;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 PyObject * obj2 = 0 ;
16662 PyObject * obj3 = 0 ;
16663 PyObject * obj4 = 0 ;
16664 PyObject * obj5 = 0 ;
16665 PyObject * obj6 = 0 ;
16666 PyObject * obj7 = 0 ;
16667 PyObject * obj8 = 0 ;
16668 PyObject * obj9 = 0 ;
16669 PyObject * obj10 = 0 ;
16670 PyObject * obj11 = 0 ;
16671 char *kwnames[] = {
16672 (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
16673 };
16674
16675 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;
16676 {
16677 arg1 = (int)(SWIG_As_int(obj0));
16678 if (SWIG_arg_fail(1)) SWIG_fail;
16679 }
16680 {
16681 arg2 = (wxEventType)(SWIG_As_int(obj1));
16682 if (SWIG_arg_fail(2)) SWIG_fail;
16683 }
16684 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16685 if (SWIG_arg_fail(3)) SWIG_fail;
16686 if (obj3) {
16687 {
16688 arg4 = (int)(SWIG_As_int(obj3));
16689 if (SWIG_arg_fail(4)) SWIG_fail;
16690 }
16691 }
16692 if (obj4) {
16693 {
16694 arg5 = (int)(SWIG_As_int(obj4));
16695 if (SWIG_arg_fail(5)) SWIG_fail;
16696 }
16697 }
16698 if (obj5) {
16699 {
16700 arg6 = (int)(SWIG_As_int(obj5));
16701 if (SWIG_arg_fail(6)) SWIG_fail;
16702 }
16703 }
16704 if (obj6) {
16705 {
16706 arg7 = (int)(SWIG_As_int(obj6));
16707 if (SWIG_arg_fail(7)) SWIG_fail;
16708 }
16709 }
16710 if (obj7) {
16711 {
16712 arg8 = (bool)(SWIG_As_bool(obj7));
16713 if (SWIG_arg_fail(8)) SWIG_fail;
16714 }
16715 }
16716 if (obj8) {
16717 {
16718 arg9 = (bool)(SWIG_As_bool(obj8));
16719 if (SWIG_arg_fail(9)) SWIG_fail;
16720 }
16721 }
16722 if (obj9) {
16723 {
16724 arg10 = (bool)(SWIG_As_bool(obj9));
16725 if (SWIG_arg_fail(10)) SWIG_fail;
16726 }
16727 }
16728 if (obj10) {
16729 {
16730 arg11 = (bool)(SWIG_As_bool(obj10));
16731 if (SWIG_arg_fail(11)) SWIG_fail;
16732 }
16733 }
16734 if (obj11) {
16735 {
16736 arg12 = (bool)(SWIG_As_bool(obj11));
16737 if (SWIG_arg_fail(12)) SWIG_fail;
16738 }
16739 }
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj;
16756 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16757 int result;
16758 PyObject * obj0 = 0 ;
16759 char *kwnames[] = {
16760 (char *) "self", NULL
16761 };
16762
16763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16765 if (SWIG_arg_fail(1)) SWIG_fail;
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (int)(arg1)->GetRow();
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 {
16774 resultobj = SWIG_From_int((int)(result));
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16785 int result;
16786 PyObject * obj0 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (int)(arg1)->GetCol();
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 resultobj = SWIG_From_int((int)(result));
16803 }
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16811 PyObject *resultobj;
16812 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16813 wxPoint result;
16814 PyObject * obj0 = 0 ;
16815 char *kwnames[] = {
16816 (char *) "self", NULL
16817 };
16818
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 result = (arg1)->GetPosition();
16825
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 {
16830 wxPoint * resultptr;
16831 resultptr = new wxPoint((wxPoint &)(result));
16832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16843 bool result;
16844 PyObject * obj0 = 0 ;
16845 char *kwnames[] = {
16846 (char *) "self", NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
16850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16851 if (SWIG_arg_fail(1)) SWIG_fail;
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = (bool)(arg1)->Selecting();
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 {
16860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16861 }
16862 return resultobj;
16863 fail:
16864 return NULL;
16865 }
16866
16867
16868 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj;
16870 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16871 bool result;
16872 PyObject * obj0 = 0 ;
16873 char *kwnames[] = {
16874 (char *) "self", NULL
16875 };
16876
16877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
16878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16879 if (SWIG_arg_fail(1)) SWIG_fail;
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 result = (bool)(arg1)->ControlDown();
16883
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 {
16888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16889 }
16890 return resultobj;
16891 fail:
16892 return NULL;
16893 }
16894
16895
16896 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16897 PyObject *resultobj;
16898 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16899 bool result;
16900 PyObject * obj0 = 0 ;
16901 char *kwnames[] = {
16902 (char *) "self", NULL
16903 };
16904
16905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
16906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16907 if (SWIG_arg_fail(1)) SWIG_fail;
16908 {
16909 PyThreadState* __tstate = wxPyBeginAllowThreads();
16910 result = (bool)(arg1)->MetaDown();
16911
16912 wxPyEndAllowThreads(__tstate);
16913 if (PyErr_Occurred()) SWIG_fail;
16914 }
16915 {
16916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16917 }
16918 return resultobj;
16919 fail:
16920 return NULL;
16921 }
16922
16923
16924 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16925 PyObject *resultobj;
16926 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16927 bool result;
16928 PyObject * obj0 = 0 ;
16929 char *kwnames[] = {
16930 (char *) "self", NULL
16931 };
16932
16933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
16934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16935 if (SWIG_arg_fail(1)) SWIG_fail;
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 result = (bool)(arg1)->ShiftDown();
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 {
16944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16945 }
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj;
16954 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16955 bool result;
16956 PyObject * obj0 = 0 ;
16957 char *kwnames[] = {
16958 (char *) "self", NULL
16959 };
16960
16961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
16962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16963 if (SWIG_arg_fail(1)) SWIG_fail;
16964 {
16965 PyThreadState* __tstate = wxPyBeginAllowThreads();
16966 result = (bool)(arg1)->AltDown();
16967
16968 wxPyEndAllowThreads(__tstate);
16969 if (PyErr_Occurred()) SWIG_fail;
16970 }
16971 {
16972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16973 }
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
16981 PyObject *obj;
16982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16983 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
16984 Py_INCREF(obj);
16985 return Py_BuildValue((char *)"");
16986 }
16987 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 int arg1 ;
16990 wxEventType arg2 ;
16991 wxGrid *arg3 = (wxGrid *) 0 ;
16992 int arg4 = (int) -1 ;
16993 int arg5 = (int) -1 ;
16994 int arg6 = (int) -1 ;
16995 bool arg7 = (bool) false ;
16996 bool arg8 = (bool) false ;
16997 bool arg9 = (bool) false ;
16998 bool arg10 = (bool) false ;
16999 wxGridSizeEvent *result;
17000 PyObject * obj0 = 0 ;
17001 PyObject * obj1 = 0 ;
17002 PyObject * obj2 = 0 ;
17003 PyObject * obj3 = 0 ;
17004 PyObject * obj4 = 0 ;
17005 PyObject * obj5 = 0 ;
17006 PyObject * obj6 = 0 ;
17007 PyObject * obj7 = 0 ;
17008 PyObject * obj8 = 0 ;
17009 PyObject * obj9 = 0 ;
17010 char *kwnames[] = {
17011 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17012 };
17013
17014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17015 {
17016 arg1 = (int)(SWIG_As_int(obj0));
17017 if (SWIG_arg_fail(1)) SWIG_fail;
17018 }
17019 {
17020 arg2 = (wxEventType)(SWIG_As_int(obj1));
17021 if (SWIG_arg_fail(2)) SWIG_fail;
17022 }
17023 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17024 if (SWIG_arg_fail(3)) SWIG_fail;
17025 if (obj3) {
17026 {
17027 arg4 = (int)(SWIG_As_int(obj3));
17028 if (SWIG_arg_fail(4)) SWIG_fail;
17029 }
17030 }
17031 if (obj4) {
17032 {
17033 arg5 = (int)(SWIG_As_int(obj4));
17034 if (SWIG_arg_fail(5)) SWIG_fail;
17035 }
17036 }
17037 if (obj5) {
17038 {
17039 arg6 = (int)(SWIG_As_int(obj5));
17040 if (SWIG_arg_fail(6)) SWIG_fail;
17041 }
17042 }
17043 if (obj6) {
17044 {
17045 arg7 = (bool)(SWIG_As_bool(obj6));
17046 if (SWIG_arg_fail(7)) SWIG_fail;
17047 }
17048 }
17049 if (obj7) {
17050 {
17051 arg8 = (bool)(SWIG_As_bool(obj7));
17052 if (SWIG_arg_fail(8)) SWIG_fail;
17053 }
17054 }
17055 if (obj8) {
17056 {
17057 arg9 = (bool)(SWIG_As_bool(obj8));
17058 if (SWIG_arg_fail(9)) SWIG_fail;
17059 }
17060 }
17061 if (obj9) {
17062 {
17063 arg10 = (bool)(SWIG_As_bool(obj9));
17064 if (SWIG_arg_fail(10)) SWIG_fail;
17065 }
17066 }
17067 {
17068 PyThreadState* __tstate = wxPyBeginAllowThreads();
17069 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17070
17071 wxPyEndAllowThreads(__tstate);
17072 if (PyErr_Occurred()) SWIG_fail;
17073 }
17074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17084 int result;
17085 PyObject * obj0 = 0 ;
17086 char *kwnames[] = {
17087 (char *) "self", NULL
17088 };
17089
17090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17092 if (SWIG_arg_fail(1)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (int)(arg1)->GetRowOrCol();
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 {
17101 resultobj = SWIG_From_int((int)(result));
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17112 wxPoint result;
17113 PyObject * obj0 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (arg1)->GetPosition();
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 wxPoint * resultptr;
17130 resultptr = new wxPoint((wxPoint &)(result));
17131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17142 bool result;
17143 PyObject * obj0 = 0 ;
17144 char *kwnames[] = {
17145 (char *) "self", NULL
17146 };
17147
17148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17150 if (SWIG_arg_fail(1)) SWIG_fail;
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (bool)(arg1)->ControlDown();
17154
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 {
17159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17160 }
17161 return resultobj;
17162 fail:
17163 return NULL;
17164 }
17165
17166
17167 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj;
17169 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17170 bool result;
17171 PyObject * obj0 = 0 ;
17172 char *kwnames[] = {
17173 (char *) "self", NULL
17174 };
17175
17176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17178 if (SWIG_arg_fail(1)) SWIG_fail;
17179 {
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (bool)(arg1)->MetaDown();
17182
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 {
17187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17188 }
17189 return resultobj;
17190 fail:
17191 return NULL;
17192 }
17193
17194
17195 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17196 PyObject *resultobj;
17197 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17198 bool result;
17199 PyObject * obj0 = 0 ;
17200 char *kwnames[] = {
17201 (char *) "self", NULL
17202 };
17203
17204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17206 if (SWIG_arg_fail(1)) SWIG_fail;
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (bool)(arg1)->ShiftDown();
17210
17211 wxPyEndAllowThreads(__tstate);
17212 if (PyErr_Occurred()) SWIG_fail;
17213 }
17214 {
17215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17216 }
17217 return resultobj;
17218 fail:
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17226 bool result;
17227 PyObject * obj0 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "self", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (bool)(arg1)->AltDown();
17238
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 {
17243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17244 }
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17252 PyObject *obj;
17253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17254 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17255 Py_INCREF(obj);
17256 return Py_BuildValue((char *)"");
17257 }
17258 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 int arg1 ;
17261 wxEventType arg2 ;
17262 wxGrid *arg3 = (wxGrid *) 0 ;
17263 wxGridCellCoords *arg4 = 0 ;
17264 wxGridCellCoords *arg5 = 0 ;
17265 bool arg6 = (bool) true ;
17266 bool arg7 = (bool) false ;
17267 bool arg8 = (bool) false ;
17268 bool arg9 = (bool) false ;
17269 bool arg10 = (bool) false ;
17270 wxGridRangeSelectEvent *result;
17271 wxGridCellCoords temp4 ;
17272 wxGridCellCoords temp5 ;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 PyObject * obj2 = 0 ;
17276 PyObject * obj3 = 0 ;
17277 PyObject * obj4 = 0 ;
17278 PyObject * obj5 = 0 ;
17279 PyObject * obj6 = 0 ;
17280 PyObject * obj7 = 0 ;
17281 PyObject * obj8 = 0 ;
17282 PyObject * obj9 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17288 {
17289 arg1 = (int)(SWIG_As_int(obj0));
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 }
17292 {
17293 arg2 = (wxEventType)(SWIG_As_int(obj1));
17294 if (SWIG_arg_fail(2)) SWIG_fail;
17295 }
17296 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17297 if (SWIG_arg_fail(3)) SWIG_fail;
17298 {
17299 arg4 = &temp4;
17300 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17301 }
17302 {
17303 arg5 = &temp5;
17304 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17305 }
17306 if (obj5) {
17307 {
17308 arg6 = (bool)(SWIG_As_bool(obj5));
17309 if (SWIG_arg_fail(6)) SWIG_fail;
17310 }
17311 }
17312 if (obj6) {
17313 {
17314 arg7 = (bool)(SWIG_As_bool(obj6));
17315 if (SWIG_arg_fail(7)) SWIG_fail;
17316 }
17317 }
17318 if (obj7) {
17319 {
17320 arg8 = (bool)(SWIG_As_bool(obj7));
17321 if (SWIG_arg_fail(8)) SWIG_fail;
17322 }
17323 }
17324 if (obj8) {
17325 {
17326 arg9 = (bool)(SWIG_As_bool(obj8));
17327 if (SWIG_arg_fail(9)) SWIG_fail;
17328 }
17329 }
17330 if (obj9) {
17331 {
17332 arg10 = (bool)(SWIG_As_bool(obj9));
17333 if (SWIG_arg_fail(10)) SWIG_fail;
17334 }
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17339
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17351 PyObject *resultobj;
17352 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17353 wxGridCellCoords result;
17354 PyObject * obj0 = 0 ;
17355 char *kwnames[] = {
17356 (char *) "self", NULL
17357 };
17358
17359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17361 if (SWIG_arg_fail(1)) SWIG_fail;
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (arg1)->GetTopLeftCoords();
17365
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 {
17370 wxGridCellCoords * resultptr;
17371 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17373 }
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17383 wxGridCellCoords result;
17384 PyObject * obj0 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17391 if (SWIG_arg_fail(1)) SWIG_fail;
17392 {
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 result = (arg1)->GetBottomRightCoords();
17395
17396 wxPyEndAllowThreads(__tstate);
17397 if (PyErr_Occurred()) SWIG_fail;
17398 }
17399 {
17400 wxGridCellCoords * resultptr;
17401 resultptr = new wxGridCellCoords((wxGridCellCoords &)(result));
17402 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17403 }
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17413 int result;
17414 PyObject * obj0 = 0 ;
17415 char *kwnames[] = {
17416 (char *) "self", NULL
17417 };
17418
17419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17421 if (SWIG_arg_fail(1)) SWIG_fail;
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (int)(arg1)->GetTopRow();
17425
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 resultobj = SWIG_From_int((int)(result));
17431 }
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj;
17440 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17441 int result;
17442 PyObject * obj0 = 0 ;
17443 char *kwnames[] = {
17444 (char *) "self", NULL
17445 };
17446
17447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17449 if (SWIG_arg_fail(1)) SWIG_fail;
17450 {
17451 PyThreadState* __tstate = wxPyBeginAllowThreads();
17452 result = (int)(arg1)->GetBottomRow();
17453
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 {
17458 resultobj = SWIG_From_int((int)(result));
17459 }
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17469 int result;
17470 PyObject * obj0 = 0 ;
17471 char *kwnames[] = {
17472 (char *) "self", NULL
17473 };
17474
17475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17477 if (SWIG_arg_fail(1)) SWIG_fail;
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 result = (int)(arg1)->GetLeftCol();
17481
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 {
17486 resultobj = SWIG_From_int((int)(result));
17487 }
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17497 int result;
17498 PyObject * obj0 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17505 if (SWIG_arg_fail(1)) SWIG_fail;
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (int)(arg1)->GetRightCol();
17509
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 {
17514 resultobj = SWIG_From_int((int)(result));
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj;
17524 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17525 bool result;
17526 PyObject * obj0 = 0 ;
17527 char *kwnames[] = {
17528 (char *) "self", NULL
17529 };
17530
17531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17533 if (SWIG_arg_fail(1)) SWIG_fail;
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = (bool)(arg1)->Selecting();
17537
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 {
17542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17543 }
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17553 bool result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = (bool)(arg1)->ControlDown();
17565
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 {
17570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17571 }
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17579 PyObject *resultobj;
17580 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17581 bool result;
17582 PyObject * obj0 = 0 ;
17583 char *kwnames[] = {
17584 (char *) "self", NULL
17585 };
17586
17587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17589 if (SWIG_arg_fail(1)) SWIG_fail;
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)(arg1)->MetaDown();
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17599 }
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17609 bool result;
17610 PyObject * obj0 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)(arg1)->ShiftDown();
17621
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17627 }
17628 return resultobj;
17629 fail:
17630 return NULL;
17631 }
17632
17633
17634 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17635 PyObject *resultobj;
17636 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17637 bool result;
17638 PyObject * obj0 = 0 ;
17639 char *kwnames[] = {
17640 (char *) "self", NULL
17641 };
17642
17643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17645 if (SWIG_arg_fail(1)) SWIG_fail;
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (bool)(arg1)->AltDown();
17649
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 {
17654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17655 }
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17663 PyObject *obj;
17664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17665 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17666 Py_INCREF(obj);
17667 return Py_BuildValue((char *)"");
17668 }
17669 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17670 PyObject *resultobj;
17671 int arg1 ;
17672 wxEventType arg2 ;
17673 wxObject *arg3 = (wxObject *) 0 ;
17674 int arg4 ;
17675 int arg5 ;
17676 wxControl *arg6 = (wxControl *) 0 ;
17677 wxGridEditorCreatedEvent *result;
17678 PyObject * obj0 = 0 ;
17679 PyObject * obj1 = 0 ;
17680 PyObject * obj2 = 0 ;
17681 PyObject * obj3 = 0 ;
17682 PyObject * obj4 = 0 ;
17683 PyObject * obj5 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17689 {
17690 arg1 = (int)(SWIG_As_int(obj0));
17691 if (SWIG_arg_fail(1)) SWIG_fail;
17692 }
17693 {
17694 arg2 = (wxEventType)(SWIG_As_int(obj1));
17695 if (SWIG_arg_fail(2)) SWIG_fail;
17696 }
17697 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(3)) SWIG_fail;
17699 {
17700 arg4 = (int)(SWIG_As_int(obj3));
17701 if (SWIG_arg_fail(4)) SWIG_fail;
17702 }
17703 {
17704 arg5 = (int)(SWIG_As_int(obj4));
17705 if (SWIG_arg_fail(5)) SWIG_fail;
17706 }
17707 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(6)) SWIG_fail;
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17712
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17726 int result;
17727 PyObject * obj0 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "self", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (int)(arg1)->GetRow();
17738
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = SWIG_From_int((int)(result));
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17754 int result;
17755 PyObject * obj0 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 {
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 result = (int)(arg1)->GetCol();
17766
17767 wxPyEndAllowThreads(__tstate);
17768 if (PyErr_Occurred()) SWIG_fail;
17769 }
17770 {
17771 resultobj = SWIG_From_int((int)(result));
17772 }
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17780 PyObject *resultobj;
17781 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17782 wxControl *result;
17783 PyObject * obj0 = 0 ;
17784 char *kwnames[] = {
17785 (char *) "self", NULL
17786 };
17787
17788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
17789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17790 if (SWIG_arg_fail(1)) SWIG_fail;
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (wxControl *)(arg1)->GetControl();
17794
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 {
17799 resultobj = wxPyMake_wxObject(result, 0);
17800 }
17801 return resultobj;
17802 fail:
17803 return NULL;
17804 }
17805
17806
17807 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17808 PyObject *resultobj;
17809 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17810 int arg2 ;
17811 PyObject * obj0 = 0 ;
17812 PyObject * obj1 = 0 ;
17813 char *kwnames[] = {
17814 (char *) "self",(char *) "row", NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
17818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17819 if (SWIG_arg_fail(1)) SWIG_fail;
17820 {
17821 arg2 = (int)(SWIG_As_int(obj1));
17822 if (SWIG_arg_fail(2)) SWIG_fail;
17823 }
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 (arg1)->SetRow(arg2);
17827
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 Py_INCREF(Py_None); resultobj = Py_None;
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17839 PyObject *resultobj;
17840 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17841 int arg2 ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "self",(char *) "col", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
17849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17850 if (SWIG_arg_fail(1)) SWIG_fail;
17851 {
17852 arg2 = (int)(SWIG_As_int(obj1));
17853 if (SWIG_arg_fail(2)) SWIG_fail;
17854 }
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 (arg1)->SetCol(arg2);
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 Py_INCREF(Py_None); resultobj = Py_None;
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17870 PyObject *resultobj;
17871 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17872 wxControl *arg2 = (wxControl *) 0 ;
17873 PyObject * obj0 = 0 ;
17874 PyObject * obj1 = 0 ;
17875 char *kwnames[] = {
17876 (char *) "self",(char *) "ctrl", NULL
17877 };
17878
17879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
17880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17881 if (SWIG_arg_fail(1)) SWIG_fail;
17882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(2)) SWIG_fail;
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 (arg1)->SetControl(arg2);
17887
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 Py_INCREF(Py_None); resultobj = Py_None;
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
17899 PyObject *obj;
17900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17901 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
17902 Py_INCREF(obj);
17903 return Py_BuildValue((char *)"");
17904 }
17905 static PyMethodDef SwigMethods[] = {
17906 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17907 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17908 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17909 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17910 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
17911 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
17912 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17913 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
17914 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17915 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17916 { (char *)"PyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17917 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
17918 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17919 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
17920 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17921 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
17922 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17923 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17924 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
17925 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17926 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
17927 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
17928 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17929 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
17930 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17931 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
17932 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17933 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
17934 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
17935 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
17936 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17937 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
17938 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17939 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
17940 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17941 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17942 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17943 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17944 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17945 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
17946 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17947 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
17948 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
17949 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17950 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17951 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17952 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17953 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17954 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17955 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17956 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17957 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17958 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
17959 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17960 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17961 { (char *)"PyGridCellEditor_base_SetSize", (PyCFunction) _wrap_PyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
17962 { (char *)"PyGridCellEditor_base_Show", (PyCFunction) _wrap_PyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS, NULL},
17963 { (char *)"PyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
17964 { (char *)"PyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
17965 { (char *)"PyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
17966 { (char *)"PyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
17967 { (char *)"PyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
17968 { (char *)"PyGridCellEditor_base_Destroy", (PyCFunction) _wrap_PyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
17969 { (char *)"PyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
17970 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
17971 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17972 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17973 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
17974 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17975 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17976 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
17977 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17978 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17979 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
17980 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17981 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17982 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
17983 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17984 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17985 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
17986 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17987 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17988 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
17989 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
17990 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
17991 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
17992 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
17993 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
17994 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
17995 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
17996 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
17997 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
17998 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
17999 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18000 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18001 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18002 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18003 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18004 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18005 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18006 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18007 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18008 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18009 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18010 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18011 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18012 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18013 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18014 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18015 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18016 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18017 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18018 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18019 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18020 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18021 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18022 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18023 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18024 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18025 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18026 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18027 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18028 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18029 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18030 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18031 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18032 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18033 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18034 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18035 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18036 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18037 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18038 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18039 { (char *)"PyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18040 { (char *)"PyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18041 { (char *)"PyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18042 { (char *)"PyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18043 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18044 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18045 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18046 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18047 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18048 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18049 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18050 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18051 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18052 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18053 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18054 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18055 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18056 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18057 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18058 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18059 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18060 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18061 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18062 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18063 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18064 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18065 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18066 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18067 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18068 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18069 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18070 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18071 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18072 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18073 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18074 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18075 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18076 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18077 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18078 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18079 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18080 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18081 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18082 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18083 { (char *)"PyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18084 { (char *)"PyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18085 { (char *)"PyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18086 { (char *)"PyGridTableBase_base_Clear", (PyCFunction) _wrap_PyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18087 { (char *)"PyGridTableBase_base_InsertRows", (PyCFunction) _wrap_PyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18088 { (char *)"PyGridTableBase_base_AppendRows", (PyCFunction) _wrap_PyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18089 { (char *)"PyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18090 { (char *)"PyGridTableBase_base_InsertCols", (PyCFunction) _wrap_PyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18091 { (char *)"PyGridTableBase_base_AppendCols", (PyCFunction) _wrap_PyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18092 { (char *)"PyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18093 { (char *)"PyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18094 { (char *)"PyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18095 { (char *)"PyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18096 { (char *)"PyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18097 { (char *)"PyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18098 { (char *)"PyGridTableBase_base_GetAttr", (PyCFunction) _wrap_PyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18099 { (char *)"PyGridTableBase_base_SetAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18100 { (char *)"PyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18101 { (char *)"PyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18102 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18103 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18104 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18105 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18106 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18107 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18108 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18109 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18110 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18111 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18112 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18113 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18114 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18115 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18116 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18117 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18118 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18119 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18120 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18121 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18122 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18123 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18124 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18125 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18126 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18127 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18128 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18131 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18132 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18134 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18135 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18136 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18137 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18138 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18140 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18143 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18146 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18148 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18150 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18152 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18154 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18177 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18182 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18189 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18191 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18192 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18195 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18198 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18201 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18204 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18207 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18210 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18234 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18246 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18255 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18257 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18259 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18262 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18270 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18281 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18298 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18321 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18323 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18325 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18328 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18329 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18334 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18335 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18338 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18339 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18343 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18345 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18346 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18347 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18348 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18356 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18358 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18359 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18360 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18364 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18365 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18366 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18367 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18368 { NULL, NULL, 0, NULL }
18369 };
18370
18371
18372 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18373
18374 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18375 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18376 }
18377 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18378 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18379 }
18380 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18381 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18382 }
18383 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18384 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18385 }
18386 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18387 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18388 }
18389 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18390 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18391 }
18392 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18393 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18394 }
18395 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18396 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18397 }
18398 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18399 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18400 }
18401 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18402 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18403 }
18404 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18405 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18406 }
18407 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18408 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18409 }
18410 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18411 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18412 }
18413 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18414 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18415 }
18416 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18417 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18418 }
18419 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18420 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18421 }
18422 static void *_p_wxGridTo_p_wxPanel(void *x) {
18423 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18424 }
18425 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18426 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18427 }
18428 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18429 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18430 }
18431 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18432 return (void *)((wxPanel *) ((wxPyPanel *) x));
18433 }
18434 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18435 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18436 }
18437 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18438 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18439 }
18440 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18441 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18442 }
18443 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18444 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18445 }
18446 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18447 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18448 }
18449 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18450 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18451 }
18452 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18453 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18454 }
18455 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18456 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18457 }
18458 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18459 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18460 }
18461 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18462 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18463 }
18464 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18465 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18466 }
18467 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18468 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18469 }
18470 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18471 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18472 }
18473 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18474 return (void *)((wxWindow *) ((wxMenuBar *) x));
18475 }
18476 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18477 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18478 }
18479 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18480 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18481 }
18482 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18483 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18484 }
18485 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18486 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18487 }
18488 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18489 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18490 }
18491 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18492 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18493 }
18494 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18495 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18496 }
18497 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18498 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18499 }
18500 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18501 return (void *)((wxWindow *) ((wxPanel *) x));
18502 }
18503 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18504 return (void *)((wxWindow *) ((wxStatusBar *) x));
18505 }
18506 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18507 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18508 }
18509 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18510 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18511 }
18512 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18513 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18514 }
18515 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18516 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18517 }
18518 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18519 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18520 }
18521 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18522 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18523 }
18524 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18525 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18526 }
18527 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18528 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18529 }
18530 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18531 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18532 }
18533 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18534 return (void *)((wxWindow *) ((wxSashWindow *) x));
18535 }
18536 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18537 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18538 }
18539 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18540 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18541 }
18542 static void *_p_wxControlTo_p_wxWindow(void *x) {
18543 return (void *)((wxWindow *) ((wxControl *) x));
18544 }
18545 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18546 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18547 }
18548 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18549 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18550 }
18551 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18552 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18553 }
18554 static void *_p_wxGridTo_p_wxWindow(void *x) {
18555 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18556 }
18557 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18558 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18559 }
18560 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18561 return (void *)((wxWindow *) ((wxPyWindow *) x));
18562 }
18563 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18564 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18565 }
18566 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18567 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18568 }
18569 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18570 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18571 }
18572 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18573 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18574 }
18575 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18576 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18577 }
18578 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18579 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18580 }
18581 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18582 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18583 }
18584 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18585 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18586 }
18587 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18588 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18589 }
18590 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18591 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18592 }
18593 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18594 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18595 }
18596 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18597 return (void *)((wxControl *) ((wxControlWithItems *) x));
18598 }
18599 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18600 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18601 }
18602 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18603 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18604 }
18605 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18606 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18607 }
18608 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18609 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18610 }
18611 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18612 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18613 }
18614 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18615 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18616 }
18617 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18618 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18619 }
18620 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18621 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18622 }
18623 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18624 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18625 }
18626 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18627 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18628 }
18629 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18630 return (void *)((wxEvent *) ((wxPyEvent *) x));
18631 }
18632 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18633 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18634 }
18635 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18636 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18637 }
18638 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18639 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18640 }
18641 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18642 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18643 }
18644 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18645 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18646 }
18647 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18648 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18649 }
18650 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18651 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18652 }
18653 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18654 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18655 }
18656 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18657 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18658 }
18659 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18660 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18661 }
18662 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18663 return (void *)((wxEvent *) ((wxMoveEvent *) x));
18664 }
18665 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
18666 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
18667 }
18668 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
18669 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18670 }
18671 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
18672 return (void *)((wxEvent *) ((wxPaintEvent *) x));
18673 }
18674 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
18675 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
18676 }
18677 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
18678 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
18679 }
18680 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
18681 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
18682 }
18683 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
18684 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
18685 }
18686 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
18687 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18688 }
18689 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
18690 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
18691 }
18692 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
18693 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18694 }
18695 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
18696 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18697 }
18698 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
18699 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
18700 }
18701 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
18702 return (void *)((wxEvent *) ((wxFocusEvent *) x));
18703 }
18704 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
18705 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
18706 }
18707 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
18708 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
18709 }
18710 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
18711 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18712 }
18713 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
18714 return (void *)((wxEvent *) ((wxShowEvent *) x));
18715 }
18716 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
18717 return (void *)((wxEvent *) ((wxCommandEvent *) x));
18718 }
18719 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
18720 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
18721 }
18722 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
18723 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
18724 }
18725 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
18726 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
18727 }
18728 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
18729 return (void *)((wxEvent *) ((wxKeyEvent *) x));
18730 }
18731 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
18732 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
18733 }
18734 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
18735 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
18736 }
18737 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
18738 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
18739 }
18740 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
18741 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18742 }
18743 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
18744 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18745 }
18746 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
18747 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18748 }
18749 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
18750 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
18751 }
18752 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
18753 return (void *)((wxObject *) ((wxSizerItem *) x));
18754 }
18755 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
18756 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
18757 }
18758 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
18759 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
18760 }
18761 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
18762 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
18763 }
18764 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
18765 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
18766 }
18767 static void *_p_wxSizerTo_p_wxObject(void *x) {
18768 return (void *)((wxObject *) ((wxSizer *) x));
18769 }
18770 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
18771 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
18772 }
18773 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
18774 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
18775 }
18776 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
18777 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
18778 }
18779 static void *_p_wxEventTo_p_wxObject(void *x) {
18780 return (void *)((wxObject *) ((wxEvent *) x));
18781 }
18782 static void *_p_wxFontDataTo_p_wxObject(void *x) {
18783 return (void *)((wxObject *) ((wxFontData *) x));
18784 }
18785 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
18786 return (void *)((wxObject *) ((wxPrintData *) x));
18787 }
18788 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
18789 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
18790 }
18791 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
18792 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
18793 }
18794 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
18795 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
18796 }
18797 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
18798 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
18799 }
18800 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
18801 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
18802 }
18803 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
18804 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
18805 }
18806 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
18807 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
18808 }
18809 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
18810 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
18811 }
18812 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
18813 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
18814 }
18815 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
18816 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
18817 }
18818 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
18819 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
18820 }
18821 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
18822 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18823 }
18824 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
18825 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
18826 }
18827 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
18828 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18829 }
18830 static void *_p_wxGridEventTo_p_wxObject(void *x) {
18831 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18832 }
18833 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
18834 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18835 }
18836 static void *_p_wxControlTo_p_wxObject(void *x) {
18837 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
18838 }
18839 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
18840 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
18841 }
18842 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
18843 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18844 }
18845 static void *_p_wxFSFileTo_p_wxObject(void *x) {
18846 return (void *)((wxObject *) ((wxFSFile *) x));
18847 }
18848 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
18849 return (void *)((wxObject *) ((wxFindReplaceData *) x));
18850 }
18851 static void *_p_wxGridTo_p_wxObject(void *x) {
18852 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18853 }
18854 static void *_p_wxPySizerTo_p_wxObject(void *x) {
18855 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
18856 }
18857 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
18858 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18859 }
18860 static void *_p_wxColourDataTo_p_wxObject(void *x) {
18861 return (void *)((wxObject *) ((wxColourData *) x));
18862 }
18863 static void *_p_wxPyEventTo_p_wxObject(void *x) {
18864 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
18865 }
18866 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
18867 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
18868 }
18869 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
18870 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
18871 }
18872 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
18873 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18874 }
18875 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
18876 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18877 }
18878 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
18879 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18880 }
18881 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
18882 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18883 }
18884 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
18885 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18886 }
18887 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
18888 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18889 }
18890 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
18891 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18892 }
18893 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
18894 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18895 }
18896 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
18897 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18898 }
18899 static void *_p_wxShowEventTo_p_wxObject(void *x) {
18900 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
18901 }
18902 static void *_p_wxPrinterTo_p_wxObject(void *x) {
18903 return (void *)((wxObject *) ((wxPrinter *) x));
18904 }
18905 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
18906 return (void *)((wxObject *) ((wxMenuItem *) x));
18907 }
18908 static void *_p_wxDateEventTo_p_wxObject(void *x) {
18909 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
18910 }
18911 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
18912 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
18913 }
18914 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
18915 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
18916 }
18917 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
18918 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
18919 }
18920 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
18921 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
18922 }
18923 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
18924 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
18925 }
18926 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
18927 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
18928 }
18929 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
18930 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
18931 }
18932 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
18933 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
18934 }
18935 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
18936 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18937 }
18938 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
18939 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
18940 }
18941 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
18942 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
18943 }
18944 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
18945 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
18946 }
18947 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
18948 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
18949 }
18950 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
18951 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
18952 }
18953 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
18954 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
18955 }
18956 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
18957 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
18958 }
18959 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
18960 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
18961 }
18962 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
18963 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
18964 }
18965 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
18966 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
18967 }
18968 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
18969 return (void *)((wxObject *) ((wxImageHandler *) x));
18970 }
18971 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
18972 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
18973 }
18974 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
18975 return (void *)((wxObject *) ((wxEvtHandler *) x));
18976 }
18977 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
18978 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
18979 }
18980 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
18981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18982 }
18983 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
18984 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18985 }
18986 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
18987 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18988 }
18989 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
18990 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
18991 }
18992 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
18993 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
18994 }
18995 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
18996 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18997 }
18998 static void *_p_wxImageTo_p_wxObject(void *x) {
18999 return (void *)((wxObject *) ((wxImage *) x));
19000 }
19001 static void *_p_wxFrameTo_p_wxObject(void *x) {
19002 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19003 }
19004 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
19005 return (void *)((wxObject *) ((wxPyPrintout *) x));
19006 }
19007 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19008 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19009 }
19010 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19011 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19012 }
19013 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19014 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19015 }
19016 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19017 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19018 }
19019 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19020 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19021 }
19022 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19023 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19024 }
19025 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19026 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19027 }
19028 static void *_p_wxWindowTo_p_wxObject(void *x) {
19029 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19030 }
19031 static void *_p_wxMenuTo_p_wxObject(void *x) {
19032 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19033 }
19034 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19035 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19036 }
19037 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19038 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19039 }
19040 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19041 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19042 }
19043 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19044 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19045 }
19046 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19047 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19048 }
19049 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19050 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19051 }
19052 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19053 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19054 }
19055 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19056 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19057 }
19058 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19059 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19060 }
19061 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19062 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19063 }
19064 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19065 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19066 }
19067 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19068 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19069 }
19070 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19071 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19072 }
19073 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19074 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19075 }
19076 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19077 return (void *)((wxObject *) ((wxPrintPreview *) x));
19078 }
19079 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19080 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19081 }
19082 static void *_p_wxPanelTo_p_wxObject(void *x) {
19083 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19084 }
19085 static void *_p_wxDialogTo_p_wxObject(void *x) {
19086 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19087 }
19088 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19089 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19090 }
19091 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19092 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19093 }
19094 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19095 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19096 }
19097 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19098 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19099 }
19100 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19101 return (void *)((wxObject *) ((wxPrintDialog *) x));
19102 }
19103 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19104 return (void *)((wxObject *) ((wxFileSystem *) x));
19105 }
19106 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19107 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19108 }
19109 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19110 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19111 }
19112 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19113 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19114 }
19115 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19116 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19117 }
19118 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19119 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19120 }
19121 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19122 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19123 }
19124 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19125 return (void *)((wxObject *) ((wxGridTableBase *) x));
19126 }
19127 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19128 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19129 }
19130 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19131 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19132 }
19133 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19134 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19135 }
19136 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19137 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19138 }
19139 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19140 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19141 }
19142 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19143 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19144 }
19145 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19146 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19147 }
19148 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19149 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19150 }
19151 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19152 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19153 }
19154 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19155 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19156 }
19157 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19158 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19159 }
19160 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19161 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19162 }
19163 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19164 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19165 }
19166 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19167 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19168 }
19169 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19170 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19171 }
19172 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19173 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19174 }
19175 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19176 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19177 }
19178 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19179 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19180 }
19181 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19182 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19183 }
19184 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19185 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19186 }
19187 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19188 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19189 }
19190 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19191 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19192 }
19193 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19194 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19195 }
19196 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19197 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19198 }
19199 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19200 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19201 }
19202 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19203 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19204 }
19205 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19206 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19207 }
19208 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19209 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19210 }
19211 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19212 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19213 }
19214 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19215 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19216 }
19217 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19218 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19219 }
19220 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19221 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19222 }
19223 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19224 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19225 }
19226 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19227 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19228 }
19229 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19230 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19231 }
19232 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19233 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19234 }
19235 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19236 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19237 }
19238 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19239 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19240 }
19241 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19242 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19243 }
19244 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19245 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19246 }
19247 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19248 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19249 }
19250 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19251 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19252 }
19253 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19254 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19255 }
19256 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19257 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19258 }
19259 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19260 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19261 }
19262 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19263 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19264 }
19265 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19266 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19267 }
19268 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19269 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19270 }
19271 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19272 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19273 }
19274 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19275 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19276 }
19277 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19278 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19279 }
19280 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19281 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19282 }
19283 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19284 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19285 }
19286 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19287 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19288 }
19289 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19290 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19291 }
19292 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19293 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19294 }
19295 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19296 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19297 }
19298 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19299 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19300 }
19301 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19302 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19303 }
19304 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19305 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19306 }
19307 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19308 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19309 }
19310 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19311 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19312 }
19313 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19314 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19315 }
19316 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19317 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19318 }
19319 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19320 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19321 }
19322 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19323 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19324 }
19325 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19326 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19327 }
19328 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19329 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19330 }
19331 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19332 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19333 }
19334 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19335 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19336 }
19337 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19338 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19339 }
19340 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19341 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19342 }
19343 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19344 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19345 }
19346 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19347 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19348 }
19349 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19350 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19351 }
19352 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19353 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19354 }
19355 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19356 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19357 }
19358 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19359 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19360 }
19361 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19362 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19363 }
19364 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19365 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19366 }
19367 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19368 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19369 }
19370 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19371 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19372 }
19373 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19374 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19375 }
19376 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19377 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19378 }
19379 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
19380 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
19381 }
19382 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19383 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19384 }
19385 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19386 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19387 }
19388 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19389 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19390 }
19391 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19392 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19393 }
19394 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19395 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19396 }
19397 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19398 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19399 }
19400 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19401 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19402 }
19403 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19404 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19405 }
19406 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19407 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19408 }
19409 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}};
19410 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}};
19411 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}};
19412 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}};
19413 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}};
19414 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}};
19415 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}};
19416 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}};
19417 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}};
19418 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}};
19419 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}};
19420 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}};
19421 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}};
19422 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}};
19423 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}};
19424 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}};
19425 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}};
19426 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}};
19427 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}};
19428 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}};
19429 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}};
19430 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}};
19431 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}};
19432 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}};
19433 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}};
19434 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}};
19435 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}};
19436 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19437 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontData", _p_wxFontDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintData", _p_wxPrintDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", _p_wxPyTaskBarIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridStringTable", _p_wxGridStringTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutAlgorithm", _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceData", _p_wxFindReplaceDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourData", _p_wxColourDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinter", _p_wxPrinterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintout", _p_wxPyPrintoutTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGrid", _p_wxGridTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintPreview", _p_wxPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintPreview", _p_wxPyPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialog", _p_wxPageSetupDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialog", _p_wxPrintDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridTableBase", _p_wxGridTableBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyGridTableBase", _p_wxPyGridTableBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialogData", _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialogData", _p_wxPrintDialogDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19438 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}};
19439 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}};
19440 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}};
19441 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}};
19442 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}};
19443 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}};
19444 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}};
19445 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}};
19446 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}};
19447 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}};
19448 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}};
19449 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}};
19450 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}};
19451 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}};
19452 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}};
19453 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}};
19454 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}};
19455 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}};
19456 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}};
19457 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}};
19458 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}};
19459 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}};
19460 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}};
19461 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}};
19462 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridRangeSelectEvent", _p_wxGridRangeSelectEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridSizeEvent", _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridEvent", _p_wxGridEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxGridEditorCreatedEvent", _p_wxGridEditorCreatedEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
19463 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}};
19464 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}};
19465 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}};
19466 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}};
19467 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}};
19468 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}};
19469 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}};
19470 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}};
19471
19472 static swig_type_info *swig_types_initial[] = {
19473 _swigt__p_wxGridCellNumberRenderer,
19474 _swigt__p_wxPyGridCellRenderer,
19475 _swigt__p_wxGridCellRenderer,
19476 _swigt__p_wxGridCellStringRenderer,
19477 _swigt__p_wxGridCellAttr,
19478 _swigt__p_wxGridCellFloatRenderer,
19479 _swigt__p_wxGridCellBoolRenderer,
19480 _swigt__p_wxGridCellDateTimeRenderer,
19481 _swigt__p_wxGridCellEnumRenderer,
19482 _swigt__p_wxGridCellAutoWrapStringRenderer,
19483 _swigt__p_wxColour,
19484 _swigt__p_wxDC,
19485 _swigt__p_form_ops_t,
19486 _swigt__p_wxDuplexMode,
19487 _swigt__p_wxGridTableMessage,
19488 _swigt__p_wxGrid,
19489 _swigt__p_wxVisualAttributes,
19490 _swigt__p_char,
19491 _swigt__p_wxPanel,
19492 _swigt__p_wxNotifyEvent,
19493 _swigt__p_wxGridRangeSelectEvent,
19494 _swigt__p_wxSize,
19495 _swigt__p_wxGridCellCoords,
19496 _swigt__p_wxScrolledWindow,
19497 _swigt__p_wxWindow,
19498 _swigt__p_wxFont,
19499 _swigt__p_wxControl,
19500 _swigt__p_wxEvent,
19501 _swigt__p_wxObject,
19502 _swigt__p_wxGridSizeEvent,
19503 _swigt__p_wxRect,
19504 _swigt__p_long,
19505 _swigt__p_wxPaperSize,
19506 _swigt__p_unsigned_int,
19507 _swigt__unsigned_int,
19508 _swigt__p_wxString,
19509 _swigt__p_wxEvtHandler,
19510 _swigt__p_wxPoint,
19511 _swigt__p_wxGridEvent,
19512 _swigt__p_wxGridEditorCreatedEvent,
19513 _swigt__p_wxGridTableBase,
19514 _swigt__p_wxGridCellEditor,
19515 _swigt__p_wxGridCellTextEditor,
19516 _swigt__p_wxPyGridCellEditor,
19517 _swigt__p_wxGridCellNumberEditor,
19518 _swigt__p_wxGridCellFloatEditor,
19519 _swigt__p_wxGridCellBoolEditor,
19520 _swigt__p_wxPyGridTableBase,
19521 _swigt__p_wxGridStringTable,
19522 _swigt__p_unsigned_char,
19523 _swigt__std__ptrdiff_t,
19524 _swigt__ptrdiff_t,
19525 _swigt__p_wxArrayString,
19526 _swigt__p_wxCommandEvent,
19527 _swigt__p_int,
19528 _swigt__p_wxGridCellAttrProvider,
19529 _swigt__p_wxGridCellChoiceEditor,
19530 _swigt__p_wxKeyEvent,
19531 _swigt__p_wxGridCellEnumEditor,
19532 _swigt__p_wxGridCellAutoWrapStringEditor,
19533 _swigt__p_wxPyGridCellAttrProvider,
19534 _swigt__p_unsigned_long,
19535 0
19536 };
19537
19538
19539 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
19540
19541 static swig_const_info swig_const_table[] = {
19542 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19543 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
19544 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19545 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
19546 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
19547 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
19548 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
19549 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
19550 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
19551 {0, 0, 0, 0.0, 0, 0}};
19552
19553 #ifdef __cplusplus
19554 }
19555 #endif
19556
19557
19558 #ifdef __cplusplus
19559 extern "C" {
19560 #endif
19561
19562 /* Python-specific SWIG API */
19563 #define SWIG_newvarlink() SWIG_Python_newvarlink()
19564 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
19565 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
19566
19567 /* -----------------------------------------------------------------------------
19568 * global variable support code.
19569 * ----------------------------------------------------------------------------- */
19570
19571 typedef struct swig_globalvar {
19572 char *name; /* Name of global variable */
19573 PyObject *(*get_attr)(); /* Return the current value */
19574 int (*set_attr)(PyObject *); /* Set the value */
19575 struct swig_globalvar *next;
19576 } swig_globalvar;
19577
19578 typedef struct swig_varlinkobject {
19579 PyObject_HEAD
19580 swig_globalvar *vars;
19581 } swig_varlinkobject;
19582
19583 static PyObject *
19584 swig_varlink_repr(swig_varlinkobject *v) {
19585 v = v;
19586 return PyString_FromString("<Swig global variables>");
19587 }
19588
19589 static int
19590 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
19591 swig_globalvar *var;
19592 flags = flags;
19593 fprintf(fp,"Swig global variables { ");
19594 for (var = v->vars; var; var=var->next) {
19595 fprintf(fp,"%s", var->name);
19596 if (var->next) fprintf(fp,", ");
19597 }
19598 fprintf(fp," }\n");
19599 return 0;
19600 }
19601
19602 static PyObject *
19603 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
19604 swig_globalvar *var = v->vars;
19605 while (var) {
19606 if (strcmp(var->name,n) == 0) {
19607 return (*var->get_attr)();
19608 }
19609 var = var->next;
19610 }
19611 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19612 return NULL;
19613 }
19614
19615 static int
19616 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
19617 swig_globalvar *var = v->vars;
19618 while (var) {
19619 if (strcmp(var->name,n) == 0) {
19620 return (*var->set_attr)(p);
19621 }
19622 var = var->next;
19623 }
19624 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
19625 return 1;
19626 }
19627
19628 static PyTypeObject varlinktype = {
19629 PyObject_HEAD_INIT(0)
19630 0, /* Number of items in variable part (ob_size) */
19631 (char *)"swigvarlink", /* Type name (tp_name) */
19632 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
19633 0, /* Itemsize (tp_itemsize) */
19634 0, /* Deallocator (tp_dealloc) */
19635 (printfunc) swig_varlink_print, /* Print (tp_print) */
19636 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
19637 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
19638 0, /* tp_compare */
19639 (reprfunc) swig_varlink_repr, /* tp_repr */
19640 0, /* tp_as_number */
19641 0, /* tp_as_sequence */
19642 0, /* tp_as_mapping */
19643 0, /* tp_hash */
19644 0, /* tp_call */
19645 0, /* tp_str */
19646 0, /* tp_getattro */
19647 0, /* tp_setattro */
19648 0, /* tp_as_buffer */
19649 0, /* tp_flags */
19650 0, /* tp_doc */
19651 #if PY_VERSION_HEX >= 0x02000000
19652 0, /* tp_traverse */
19653 0, /* tp_clear */
19654 #endif
19655 #if PY_VERSION_HEX >= 0x02010000
19656 0, /* tp_richcompare */
19657 0, /* tp_weaklistoffset */
19658 #endif
19659 #if PY_VERSION_HEX >= 0x02020000
19660 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
19661 #endif
19662 #if PY_VERSION_HEX >= 0x02030000
19663 0, /* tp_del */
19664 #endif
19665 #ifdef COUNT_ALLOCS
19666 0,0,0,0 /* tp_alloc -> tp_next */
19667 #endif
19668 };
19669
19670 /* Create a variable linking object for use later */
19671 static PyObject *
19672 SWIG_Python_newvarlink(void) {
19673 swig_varlinkobject *result = 0;
19674 result = PyMem_NEW(swig_varlinkobject,1);
19675 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
19676 result->ob_type = &varlinktype;
19677 result->vars = 0;
19678 result->ob_refcnt = 0;
19679 Py_XINCREF((PyObject *) result);
19680 return ((PyObject*) result);
19681 }
19682
19683 static void
19684 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
19685 swig_varlinkobject *v;
19686 swig_globalvar *gv;
19687 v= (swig_varlinkobject *) p;
19688 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
19689 gv->name = (char *) malloc(strlen(name)+1);
19690 strcpy(gv->name,name);
19691 gv->get_attr = get_attr;
19692 gv->set_attr = set_attr;
19693 gv->next = v->vars;
19694 v->vars = gv;
19695 }
19696
19697 /* -----------------------------------------------------------------------------
19698 * constants/methods manipulation
19699 * ----------------------------------------------------------------------------- */
19700
19701 /* Install Constants */
19702 static void
19703 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
19704 PyObject *obj = 0;
19705 size_t i;
19706 for (i = 0; constants[i].type; i++) {
19707 switch(constants[i].type) {
19708 case SWIG_PY_INT:
19709 obj = PyInt_FromLong(constants[i].lvalue);
19710 break;
19711 case SWIG_PY_FLOAT:
19712 obj = PyFloat_FromDouble(constants[i].dvalue);
19713 break;
19714 case SWIG_PY_STRING:
19715 if (constants[i].pvalue) {
19716 obj = PyString_FromString((char *) constants[i].pvalue);
19717 } else {
19718 Py_INCREF(Py_None);
19719 obj = Py_None;
19720 }
19721 break;
19722 case SWIG_PY_POINTER:
19723 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
19724 break;
19725 case SWIG_PY_BINARY:
19726 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
19727 break;
19728 default:
19729 obj = 0;
19730 break;
19731 }
19732 if (obj) {
19733 PyDict_SetItemString(d,constants[i].name,obj);
19734 Py_DECREF(obj);
19735 }
19736 }
19737 }
19738
19739 /* -----------------------------------------------------------------------------*/
19740 /* Fix SwigMethods to carry the callback ptrs when needed */
19741 /* -----------------------------------------------------------------------------*/
19742
19743 static void
19744 SWIG_Python_FixMethods(PyMethodDef *methods,
19745 swig_const_info *const_table,
19746 swig_type_info **types,
19747 swig_type_info **types_initial) {
19748 size_t i;
19749 for (i = 0; methods[i].ml_name; ++i) {
19750 char *c = methods[i].ml_doc;
19751 if (c && (c = strstr(c, "swig_ptr: "))) {
19752 int j;
19753 swig_const_info *ci = 0;
19754 char *name = c + 10;
19755 for (j = 0; const_table[j].type; j++) {
19756 if (strncmp(const_table[j].name, name,
19757 strlen(const_table[j].name)) == 0) {
19758 ci = &(const_table[j]);
19759 break;
19760 }
19761 }
19762 if (ci) {
19763 size_t shift = (ci->ptype) - types;
19764 swig_type_info *ty = types_initial[shift];
19765 size_t ldoc = (c - methods[i].ml_doc);
19766 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
19767 char *ndoc = (char*)malloc(ldoc + lptr + 10);
19768 char *buff = ndoc;
19769 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
19770 strncpy(buff, methods[i].ml_doc, ldoc);
19771 buff += ldoc;
19772 strncpy(buff, "swig_ptr: ", 10);
19773 buff += 10;
19774 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
19775 methods[i].ml_doc = ndoc;
19776 }
19777 }
19778 }
19779 }
19780
19781 /* -----------------------------------------------------------------------------*
19782 * Initialize type list
19783 * -----------------------------------------------------------------------------*/
19784
19785 #if PY_MAJOR_VERSION < 2
19786 /* PyModule_AddObject function was introduced in Python 2.0. The following function
19787 is copied out of Python/modsupport.c in python version 2.3.4 */
19788 static int
19789 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
19790 {
19791 PyObject *dict;
19792 if (!PyModule_Check(m)) {
19793 PyErr_SetString(PyExc_TypeError,
19794 "PyModule_AddObject() needs module as first arg");
19795 return -1;
19796 }
19797 if (!o) {
19798 PyErr_SetString(PyExc_TypeError,
19799 "PyModule_AddObject() needs non-NULL value");
19800 return -1;
19801 }
19802
19803 dict = PyModule_GetDict(m);
19804 if (dict == NULL) {
19805 /* Internal error -- modules must have a dict! */
19806 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
19807 PyModule_GetName(m));
19808 return -1;
19809 }
19810 if (PyDict_SetItemString(dict, name, o))
19811 return -1;
19812 Py_DECREF(o);
19813 return 0;
19814 }
19815 #endif
19816
19817 static swig_type_info **
19818 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
19819 static PyMethodDef swig_empty_runtime_method_table[] = {
19820 {
19821 NULL, NULL, 0, NULL
19822 }
19823 };/* Sentinel */
19824
19825 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
19826 swig_empty_runtime_method_table);
19827 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
19828 if (pointer && module) {
19829 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
19830 }
19831 return type_list_handle;
19832 }
19833
19834 static swig_type_info **
19835 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
19836 swig_type_info **type_pointer;
19837
19838 /* first check if module already created */
19839 type_pointer = SWIG_Python_GetTypeListHandle();
19840 if (type_pointer) {
19841 return type_pointer;
19842 } else {
19843 /* create a new module and variable */
19844 return SWIG_Python_SetTypeListHandle(type_list_handle);
19845 }
19846 }
19847
19848 #ifdef __cplusplus
19849 }
19850 #endif
19851
19852 /* -----------------------------------------------------------------------------*
19853 * Partial Init method
19854 * -----------------------------------------------------------------------------*/
19855
19856 #ifdef SWIG_LINK_RUNTIME
19857 #ifdef __cplusplus
19858 extern "C"
19859 #endif
19860 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
19861 #endif
19862
19863 #ifdef __cplusplus
19864 extern "C"
19865 #endif
19866 SWIGEXPORT(void) SWIG_init(void) {
19867 static PyObject *SWIG_globals = 0;
19868 static int typeinit = 0;
19869 PyObject *m, *d;
19870 int i;
19871 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
19872
19873 /* Fix SwigMethods to carry the callback ptrs when needed */
19874 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
19875
19876 m = Py_InitModule((char *) SWIG_name, SwigMethods);
19877 d = PyModule_GetDict(m);
19878
19879 if (!typeinit) {
19880 #ifdef SWIG_LINK_RUNTIME
19881 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
19882 #else
19883 # ifndef SWIG_STATIC_RUNTIME
19884 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
19885 # endif
19886 #endif
19887 for (i = 0; swig_types_initial[i]; i++) {
19888 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
19889 }
19890 typeinit = 1;
19891 }
19892 SWIG_InstallConstants(d,swig_const_table);
19893
19894 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
19895 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
19896 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
19897 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
19898 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
19899 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
19900 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
19901 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
19902 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
19903 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
19904 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
19905 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
19906 {
19907 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_ROWS)));
19908 }
19909 {
19910 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int((int)(wxGRID_DEFAULT_NUMBER_COLS)));
19911 }
19912 {
19913 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_HEIGHT)));
19914 }
19915 {
19916 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_COL_WIDTH)));
19917 }
19918 {
19919 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int((int)(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
19920 }
19921 {
19922 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
19923 }
19924 {
19925 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int((int)(wxGRID_LABEL_EDGE_ZONE)));
19926 }
19927 {
19928 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int((int)(wxGRID_MIN_ROW_HEIGHT)));
19929 }
19930 {
19931 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int((int)(wxGRID_MIN_COL_WIDTH)));
19932 }
19933 {
19934 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int((int)(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
19935 }
19936 {
19937 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int((int)(wxGridCellAttr::Any)));
19938 }
19939 {
19940 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int((int)(wxGridCellAttr::Default)));
19941 }
19942 {
19943 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int((int)(wxGridCellAttr::Cell)));
19944 }
19945 {
19946 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int((int)(wxGridCellAttr::Row)));
19947 }
19948 {
19949 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int((int)(wxGridCellAttr::Col)));
19950 }
19951 {
19952 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int((int)(wxGridCellAttr::Merged)));
19953 }
19954 {
19955 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
19956 }
19957 {
19958 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int((int)(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
19959 }
19960 {
19961 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
19962 }
19963 {
19964 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
19965 }
19966 {
19967 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
19968 }
19969 {
19970 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
19971 }
19972 {
19973 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
19974 }
19975 {
19976 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int((int)(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
19977 }
19978 {
19979 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int((int)(wxGrid::wxGridSelectCells)));
19980 }
19981 {
19982 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int((int)(wxGrid::wxGridSelectRows)));
19983 }
19984 {
19985 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int((int)(wxGrid::wxGridSelectColumns)));
19986 }
19987 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
19988 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
19989 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
19990 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
19991 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
19992 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
19993 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
19994 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
19995 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
19996 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
19997 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
19998 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
19999 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
20000 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
20001 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
20002 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
20003 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
20004
20005
20006 }
20007
wxWidgets (Impactor)