]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:


883c934bc5aa89012b1e60a41a53a03b04c07230
[wxWidgets.git] / wxPython / src / gtk / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_long swig_types[3]
2466 #define SWIGTYPE_p_unsigned_char swig_types[4]
2467 #define SWIGTYPE_p_unsigned_int swig_types[5]
2468 #define SWIGTYPE_p_unsigned_long swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2475 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2476 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2477 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2478 #define SWIGTYPE_p_wxCloseEvent swig_types[16]
2479 #define SWIGTYPE_p_wxColour swig_types[17]
2480 #define SWIGTYPE_p_wxColourData swig_types[18]
2481 #define SWIGTYPE_p_wxColourDialog swig_types[19]
2482 #define SWIGTYPE_p_wxCommandEvent swig_types[20]
2483 #define SWIGTYPE_p_wxContextMenuEvent swig_types[21]
2484 #define SWIGTYPE_p_wxControl swig_types[22]
2485 #define SWIGTYPE_p_wxControlWithItems swig_types[23]
2486 #define SWIGTYPE_p_wxDC swig_types[24]
2487 #define SWIGTYPE_p_wxDateEvent swig_types[25]
2488 #define SWIGTYPE_p_wxDialog swig_types[26]
2489 #define SWIGTYPE_p_wxDirDialog swig_types[27]
2490 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[28]
2491 #define SWIGTYPE_p_wxDropFilesEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDuplexMode swig_types[30]
2493 #define SWIGTYPE_p_wxEraseEvent swig_types[31]
2494 #define SWIGTYPE_p_wxEvent swig_types[32]
2495 #define SWIGTYPE_p_wxEvtHandler swig_types[33]
2496 #define SWIGTYPE_p_wxFSFile swig_types[34]
2497 #define SWIGTYPE_p_wxFileDialog swig_types[35]
2498 #define SWIGTYPE_p_wxFileSystem swig_types[36]
2499 #define SWIGTYPE_p_wxFindDialogEvent swig_types[37]
2500 #define SWIGTYPE_p_wxFindReplaceData swig_types[38]
2501 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[39]
2502 #define SWIGTYPE_p_wxFlexGridSizer swig_types[40]
2503 #define SWIGTYPE_p_wxFocusEvent swig_types[41]
2504 #define SWIGTYPE_p_wxFont swig_types[42]
2505 #define SWIGTYPE_p_wxFontData swig_types[43]
2506 #define SWIGTYPE_p_wxFontDialog swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBSizerItem swig_types[46]
2509 #define SWIGTYPE_p_wxGIFHandler swig_types[47]
2510 #define SWIGTYPE_p_wxGrid swig_types[48]
2511 #define SWIGTYPE_p_wxGridBagSizer swig_types[49]
2512 #define SWIGTYPE_p_wxGridCellAttr swig_types[50]
2513 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[51]
2514 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[52]
2515 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[53]
2516 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[54]
2517 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[55]
2518 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
2519 #define SWIGTYPE_p_wxGridCellCoords swig_types[57]
2520 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[58]
2521 #define SWIGTYPE_p_wxGridCellEditor swig_types[59]
2522 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[60]
2523 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[61]
2524 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[62]
2525 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[63]
2526 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[64]
2527 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[65]
2528 #define SWIGTYPE_p_wxGridCellRenderer swig_types[66]
2529 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[67]
2530 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[68]
2531 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[69]
2532 #define SWIGTYPE_p_wxGridEvent swig_types[70]
2533 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[71]
2534 #define SWIGTYPE_p_wxGridSizeEvent swig_types[72]
2535 #define SWIGTYPE_p_wxGridSizer swig_types[73]
2536 #define SWIGTYPE_p_wxGridStringTable swig_types[74]
2537 #define SWIGTYPE_p_wxGridTableBase swig_types[75]
2538 #define SWIGTYPE_p_wxGridTableMessage swig_types[76]
2539 #define SWIGTYPE_p_wxICOHandler swig_types[77]
2540 #define SWIGTYPE_p_wxIconizeEvent swig_types[78]
2541 #define SWIGTYPE_p_wxIdleEvent swig_types[79]
2542 #define SWIGTYPE_p_wxImage swig_types[80]
2543 #define SWIGTYPE_p_wxImageHandler swig_types[81]
2544 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[82]
2545 #define SWIGTYPE_p_wxInitDialogEvent swig_types[83]
2546 #define SWIGTYPE_p_wxJPEGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxKeyEvent swig_types[85]
2548 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[86]
2549 #define SWIGTYPE_p_wxLayoutConstraints swig_types[87]
2550 #define SWIGTYPE_p_wxMDIChildFrame swig_types[88]
2551 #define SWIGTYPE_p_wxMDIClientWindow swig_types[89]
2552 #define SWIGTYPE_p_wxMDIParentFrame swig_types[90]
2553 #define SWIGTYPE_p_wxMaximizeEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenu swig_types[92]
2555 #define SWIGTYPE_p_wxMenuBar swig_types[93]
2556 #define SWIGTYPE_p_wxMenuEvent swig_types[94]
2557 #define SWIGTYPE_p_wxMenuItem swig_types[95]
2558 #define SWIGTYPE_p_wxMessageDialog swig_types[96]
2559 #define SWIGTYPE_p_wxMiniFrame swig_types[97]
2560 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[101]
2564 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2566 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2567 #define SWIGTYPE_p_wxObject swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPageSetupDialog swig_types[109]
2572 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[110]
2573 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2574 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPanel swig_types[113]
2576 #define SWIGTYPE_p_wxPaperSize swig_types[114]
2577 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[115]
2578 #define SWIGTYPE_p_wxPoint swig_types[116]
2579 #define SWIGTYPE_p_wxPopupWindow swig_types[117]
2580 #define SWIGTYPE_p_wxPreviewCanvas swig_types[118]
2581 #define SWIGTYPE_p_wxPreviewControlBar swig_types[119]
2582 #define SWIGTYPE_p_wxPreviewFrame swig_types[120]
2583 #define SWIGTYPE_p_wxPrintData swig_types[121]
2584 #define SWIGTYPE_p_wxPrintDialog swig_types[122]
2585 #define SWIGTYPE_p_wxPrintDialogData swig_types[123]
2586 #define SWIGTYPE_p_wxPrintPreview swig_types[124]
2587 #define SWIGTYPE_p_wxPrinter swig_types[125]
2588 #define SWIGTYPE_p_wxProgressDialog swig_types[126]
2589 #define SWIGTYPE_p_wxPyApp swig_types[127]
2590 #define SWIGTYPE_p_wxPyCommandEvent swig_types[128]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[129]
2592 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[130]
2593 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[131]
2594 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[132]
2595 #define SWIGTYPE_p_wxPyGridTableBase swig_types[133]
2596 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[134]
2597 #define SWIGTYPE_p_wxPyImageHandler swig_types[135]
2598 #define SWIGTYPE_p_wxPyPanel swig_types[136]
2599 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[137]
2600 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[138]
2601 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[139]
2602 #define SWIGTYPE_p_wxPyPrintPreview swig_types[140]
2603 #define SWIGTYPE_p_wxPyPrintout swig_types[141]
2604 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[142]
2605 #define SWIGTYPE_p_wxPySizer swig_types[143]
2606 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[144]
2607 #define SWIGTYPE_p_wxPyVListBox swig_types[145]
2608 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[146]
2609 #define SWIGTYPE_p_wxPyValidator swig_types[147]
2610 #define SWIGTYPE_p_wxPyWindow swig_types[148]
2611 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[149]
2612 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[150]
2613 #define SWIGTYPE_p_wxRect swig_types[151]
2614 #define SWIGTYPE_p_wxSashEvent swig_types[152]
2615 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[153]
2616 #define SWIGTYPE_p_wxSashWindow swig_types[154]
2617 #define SWIGTYPE_p_wxScrollEvent swig_types[155]
2618 #define SWIGTYPE_p_wxScrollWinEvent swig_types[156]
2619 #define SWIGTYPE_p_wxScrolledWindow swig_types[157]
2620 #define SWIGTYPE_p_wxSetCursorEvent swig_types[158]
2621 #define SWIGTYPE_p_wxShowEvent swig_types[159]
2622 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[160]
2623 #define SWIGTYPE_p_wxSize swig_types[161]
2624 #define SWIGTYPE_p_wxSizeEvent swig_types[162]
2625 #define SWIGTYPE_p_wxSizer swig_types[163]
2626 #define SWIGTYPE_p_wxSizerItem swig_types[164]
2627 #define SWIGTYPE_p_wxSplashScreen swig_types[165]
2628 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[166]
2629 #define SWIGTYPE_p_wxSplitterEvent swig_types[167]
2630 #define SWIGTYPE_p_wxSplitterWindow swig_types[168]
2631 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[169]
2632 #define SWIGTYPE_p_wxStatusBar swig_types[170]
2633 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[171]
2634 #define SWIGTYPE_p_wxString swig_types[172]
2635 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[173]
2636 #define SWIGTYPE_p_wxTIFFHandler swig_types[174]
2637 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[175]
2638 #define SWIGTYPE_p_wxTextEntryDialog swig_types[176]
2639 #define SWIGTYPE_p_wxTipWindow swig_types[177]
2640 #define SWIGTYPE_p_wxTopLevelWindow swig_types[178]
2641 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[179]
2642 #define SWIGTYPE_p_wxValidator swig_types[180]
2643 #define SWIGTYPE_p_wxVisualAttributes swig_types[181]
2644 #define SWIGTYPE_p_wxWindow swig_types[182]
2645 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[183]
2646 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[184]
2647 #define SWIGTYPE_p_wxXPMHandler swig_types[185]
2648 static swig_type_info *swig_types[187];
2649 static swig_module_info swig_module = {swig_types, 186, 0, 0, 0, 0};
2650 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2651 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2652
2653 /* -------- TYPES TABLE (END) -------- */
2654
2655 #if (PY_VERSION_HEX <= 0x02000000)
2656 # if !defined(SWIG_PYTHON_CLASSIC)
2657 # error "This python version requires to use swig with the '-classic' option"
2658 # endif
2659 #endif
2660 #if (PY_VERSION_HEX <= 0x02020000)
2661 # error "This python version requires to use swig with the '-nomodern' option"
2662 #endif
2663 #if (PY_VERSION_HEX <= 0x02020000)
2664 # error "This python version requires to use swig with the '-nomodernargs' option"
2665 #endif
2666 #ifndef METH_O
2667 # error "This python version requires to use swig with the '-nofastunpack' option"
2668 #endif
2669
2670 /*-----------------------------------------------
2671 @(target):= _grid.so
2672 ------------------------------------------------*/
2673 #define SWIG_init init_grid
2674
2675 #define SWIG_name "_grid"
2676
2677 #define SWIGVERSION 0x010329
2678
2679
2680 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2681 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2682
2683
2684 #include <stdexcept>
2685
2686
2687 namespace swig {
2688 class PyObject_ptr {
2689 protected:
2690 PyObject *_obj;
2691
2692 public:
2693 PyObject_ptr() :_obj(0)
2694 {
2695 }
2696
2697 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2698 {
2699 Py_XINCREF(_obj);
2700 }
2701
2702 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2703 {
2704 if (initial_ref) Py_XINCREF(_obj);
2705 }
2706
2707 PyObject_ptr & operator=(const PyObject_ptr& item)
2708 {
2709 Py_XINCREF(item._obj);
2710 Py_XDECREF(_obj);
2711 _obj = item._obj;
2712 return *this;
2713 }
2714
2715 ~PyObject_ptr()
2716 {
2717 Py_XDECREF(_obj);
2718 }
2719
2720 operator PyObject *() const
2721 {
2722 return _obj;
2723 }
2724
2725 PyObject *operator->() const
2726 {
2727 return _obj;
2728 }
2729 };
2730 }
2731
2732
2733 namespace swig {
2734 struct PyObject_var : PyObject_ptr {
2735 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2736
2737 PyObject_var & operator = (PyObject* obj)
2738 {
2739 Py_XDECREF(_obj);
2740 _obj = obj;
2741 return *this;
2742 }
2743 };
2744 }
2745
2746
2747 #include "wx/wxPython/wxPython.h"
2748 #include "wx/wxPython/pyclasses.h"
2749 #include "wx/wxPython/printfw.h"
2750
2751 #include <wx/grid.h>
2752 #include <wx/generic/gridctrl.h>
2753
2754
2755 static const wxString wxPyEmptyString(wxEmptyString);
2756 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2757 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2758
2759
2760 #define wxPyMake_TEMPLATE(TYPE) \
2761 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2762 PyObject* target = NULL; \
2763 if (source) { \
2764 /* Check if there is already a pointer to a Python object in the \
2765 OOR data that we can use. */ \
2766 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2767 if (data) { \
2768 target = data->m_obj; \
2769 if (target) \
2770 Py_INCREF(target); \
2771 } \
2772 /* Otherwise make a new wrapper for it the old fashioned way and \
2773 give it the OOR treatment */ \
2774 if (! target) { \
2775 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2776 if (target) \
2777 source->SetClientObject(new wxPyOORClientData(target)); \
2778 } \
2779 } else { /* source was NULL so return None. */ \
2780 Py_INCREF(Py_None); target = Py_None; \
2781 } \
2782 return target; \
2783 } \
2784
2785
2786 wxPyMake_TEMPLATE(wxGridCellRenderer)
2787 wxPyMake_TEMPLATE(wxGridCellEditor)
2788 wxPyMake_TEMPLATE(wxGridCellAttr)
2789 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2790 wxPyMake_TEMPLATE(wxGridTableBase)
2791
2792
2793
2794 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2795 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2796 wxGridCellAttr* rval = NULL; \
2797 bool found; \
2798 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2799 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2800 PyObject* ro; \
2801 wxGridCellAttr* ptr; \
2802 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2803 if (ro) { \
2804 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2805 rval = ptr; \
2806 Py_DECREF(ro); \
2807 } \
2808 } \
2809 wxPyEndBlockThreads(blocked); \
2810 if (! found) \
2811 rval = PCLASS::CBNAME(a, b, c); \
2812 return rval; \
2813 }
2814
2815
2816 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2817 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2819 bool found; \
2820 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2821 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2822 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2823 Py_DECREF(obj); \
2824 } \
2825 wxPyEndBlockThreads(blocked); \
2826 if (! found) \
2827 PCLASS::CBNAME(attr, a, b); \
2828 }
2829
2830
2831
2832 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2833 void CBNAME(wxGridCellAttr *attr, int val) { \
2834 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2835 bool found; \
2836 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2837 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2838 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2839 Py_DECREF(obj); \
2840 } \
2841 wxPyEndBlockThreads(blocked); \
2842 if (! found) \
2843 PCLASS::CBNAME(attr, val); \
2844 }
2845
2846
2847
2848 #define PYCALLBACK_INT__pure(CBNAME) \
2849 int CBNAME() { \
2850 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2851 int rval = 0; \
2852 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2853 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2854 wxPyEndBlockThreads(blocked); \
2855 return rval; \
2856 }
2857
2858
2859
2860 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2861 bool CBNAME(int a, int b) { \
2862 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2863 bool rval = 0; \
2864 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2865 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2866 wxPyEndBlockThreads(blocked); \
2867 return rval; \
2868 }
2869
2870
2871 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2872 wxString CBNAME(int a, int b) { \
2873 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2874 wxString rval; \
2875 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2876 PyObject* ro; \
2877 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2878 if (ro) { \
2879 rval = Py2wxString(ro); \
2880 Py_DECREF(ro); \
2881 } \
2882 } \
2883 wxPyEndBlockThreads(blocked); \
2884 return rval; \
2885 }
2886
2887
2888 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2889 void CBNAME(int a, int b, const wxString& c) { \
2890 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2891 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2892 PyObject* s = wx2PyString(c); \
2893 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2894 Py_DECREF(s); \
2895 } \
2896 wxPyEndBlockThreads(blocked); \
2897 }
2898
2899
2900 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2901 wxString CBNAME(int a, int b) { \
2902 bool found; \
2903 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2904 wxString rval; \
2905 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2906 PyObject* ro; \
2907 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2908 if (ro) { \
2909 rval = Py2wxString(ro); \
2910 Py_DECREF(ro); \
2911 } \
2912 } \
2913 wxPyEndBlockThreads(blocked); \
2914 if (! found) \
2915 rval = PCLASS::CBNAME(a, b); \
2916 return rval; \
2917 }
2918
2919
2920 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2921 bool CBNAME(int a, int b, const wxString& c) { \
2922 bool rval = 0; \
2923 bool found; \
2924 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2925 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2926 PyObject* s = wx2PyString(c); \
2927 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2928 Py_DECREF(s); \
2929 } \
2930 wxPyEndBlockThreads(blocked); \
2931 if (! found) \
2932 rval = PCLASS::CBNAME(a,b,c); \
2933 return rval; \
2934 }
2935
2936
2937
2938
2939 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2940 long CBNAME(int a, int b) { \
2941 long rval; \
2942 bool found; \
2943 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2944 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2945 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2946 wxPyEndBlockThreads(blocked); \
2947 if (! found) \
2948 rval = PCLASS::CBNAME(a,b); \
2949 return rval; \
2950 }
2951
2952
2953 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2954 bool CBNAME(int a, int b) { \
2955 bool rval = 0; \
2956 bool found; \
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2958 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2959 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2960 wxPyEndBlockThreads(blocked); \
2961 if (! found) \
2962 rval = PCLASS::CBNAME(a,b); \
2963 return rval; \
2964 }
2965
2966
2967
2968 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2969 double CBNAME(int a, int b) { \
2970 bool found; \
2971 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2972 double rval; \
2973 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2974 PyObject* ro; \
2975 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2976 if (ro) { \
2977 PyObject* str = PyObject_Str(ro); \
2978 rval = PyFloat_AsDouble(str); \
2979 Py_DECREF(ro); Py_DECREF(str); \
2980 } \
2981 } \
2982 wxPyEndBlockThreads(blocked); \
2983 if (! found) \
2984 rval = PCLASS::CBNAME(a, b); \
2985 return rval; \
2986 }
2987
2988
2989
2990 #define PYCALLBACK__(PCLASS, CBNAME) \
2991 void CBNAME() { \
2992 bool found; \
2993 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2994 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2995 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2996 wxPyEndBlockThreads(blocked); \
2997 if (! found) \
2998 PCLASS::CBNAME(); \
2999 }
3000
3001
3002
3003 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3004 bool CBNAME(size_t a, size_t b) { \
3005 bool rval = 0; \
3006 bool found; \
3007 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3008 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3009 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3010 wxPyEndBlockThreads(blocked); \
3011 if (! found) \
3012 rval = PCLASS::CBNAME(a,b); \
3013 return rval; \
3014 }
3015
3016
3017
3018 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3019 bool CBNAME(size_t a) { \
3020 bool rval = 0; \
3021 bool found; \
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3023 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3024 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3025 wxPyEndBlockThreads(blocked); \
3026 if (! found) \
3027 rval = PCLASS::CBNAME(a); \
3028 return rval; \
3029 }
3030
3031
3032 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3033 wxString CBNAME(int a) { \
3034 bool found; \
3035 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3036 wxString rval; \
3037 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3038 PyObject* ro; \
3039 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3040 if (ro) { \
3041 rval = Py2wxString(ro); \
3042 Py_DECREF(ro); \
3043 } \
3044 } \
3045 wxPyEndBlockThreads(blocked); \
3046 if (! found) \
3047 rval = PCLASS::CBNAME(a); \
3048 return rval; \
3049 }
3050
3051
3052 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3053 void CBNAME(int a, const wxString& c) { \
3054 bool found; \
3055 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3056 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3057 PyObject* s = wx2PyString(c); \
3058 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3059 Py_DECREF(s); \
3060 } \
3061 wxPyEndBlockThreads(blocked); \
3062 if (! found) \
3063 PCLASS::CBNAME(a,c); \
3064 }
3065
3066
3067
3068
3069 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3070 bool CBNAME() { \
3071 bool rval = 0; \
3072 bool found; \
3073 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3074 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3075 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3076 wxPyEndBlockThreads(blocked); \
3077 if (! found) \
3078 rval = PCLASS::CBNAME(); \
3079 return rval; \
3080 }
3081
3082
3083
3084 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3085 void CBNAME(size_t a, int b) { \
3086 bool found; \
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3088 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3089 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3090 wxPyEndBlockThreads(blocked); \
3091 if (! found) \
3092 PCLASS::CBNAME(a,b); \
3093 }
3094
3095
3096
3097
3098 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3099 void CBNAME(int a, int b, long c) { \
3100 bool found; \
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3102 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3103 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3104 wxPyEndBlockThreads(blocked); \
3105 if (! found) \
3106 PCLASS::CBNAME(a,b,c); \
3107 }
3108
3109
3110
3111
3112 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3113 void CBNAME(int a, int b, double c) { \
3114 bool found; \
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3116 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3117 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3118 wxPyEndBlockThreads(blocked); \
3119 if (! found) \
3120 PCLASS::CBNAME(a,b,c); \
3121 }
3122
3123
3124
3125 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3126 void CBNAME(int a, int b, bool c) { \
3127 bool found; \
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3129 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3130 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3131 wxPyEndBlockThreads(blocked); \
3132 if (! found) \
3133 PCLASS::CBNAME(a,b,c); \
3134 }
3135
3136
3137
3138
3139
3140 SWIGINTERN swig_type_info*
3141 SWIG_pchar_descriptor()
3142 {
3143 static int init = 0;
3144 static swig_type_info* info = 0;
3145 if (!init) {
3146 info = SWIG_TypeQuery("_p_char");
3147 init = 1;
3148 }
3149 return info;
3150 }
3151
3152
3153 SWIGINTERNINLINE PyObject *
3154 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3155 {
3156 if (carray) {
3157 if (size > INT_MAX) {
3158 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3159 return pchar_descriptor ?
3160 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3161 } else {
3162 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3163 }
3164 } else {
3165 return SWIG_Py_Void();
3166 }
3167 }
3168
3169
3170 SWIGINTERNINLINE PyObject *
3171 SWIG_FromCharPtr(const char *cptr)
3172 {
3173 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3174 }
3175
3176
3177 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3178 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3179 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3180 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3181 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3182 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3183 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3184 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3185 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3186 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3187
3188
3189 #define SWIG_From_long PyInt_FromLong
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_From_int (int value)
3194 {
3195 return SWIG_From_long (value);
3196 }
3197
3198 SWIGINTERN void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
3199 if (!self->GetClientObject())
3200 self->SetClientObject(new wxPyOORClientData(_self));
3201 }
3202
3203 #include <limits.h>
3204 #ifndef LLONG_MIN
3205 # define LLONG_MIN LONG_LONG_MIN
3206 #endif
3207 #ifndef LLONG_MAX
3208 # define LLONG_MAX LONG_LONG_MAX
3209 #endif
3210 #ifndef ULLONG_MAX
3211 # define ULLONG_MAX ULONG_LONG_MAX
3212 #endif
3213
3214
3215 SWIGINTERN int
3216 SWIG_AsVal_long (PyObject* obj, long* val)
3217 {
3218 if (PyNumber_Check(obj)) {
3219 if (val) *val = PyInt_AsLong(obj);
3220 return SWIG_OK;
3221 }
3222 return SWIG_TypeError;
3223 }
3224
3225
3226 SWIGINTERN int
3227 SWIG_AsVal_int (PyObject * obj, int *val)
3228 {
3229 long v;
3230 int res = SWIG_AsVal_long (obj, &v);
3231 if (SWIG_IsOK(res)) {
3232 if ((v < INT_MIN || v > INT_MAX)) {
3233 return SWIG_OverflowError;
3234 } else {
3235 if (val) *val = static_cast< int >(v);
3236 }
3237 }
3238 return res;
3239 }
3240
3241
3242 SWIGINTERN int
3243 SWIG_AsVal_bool (PyObject *obj, bool *val)
3244 {
3245 if (obj == Py_True) {
3246 if (val) *val = true;
3247 return SWIG_OK;
3248 } else if (obj == Py_False) {
3249 if (val) *val = false;
3250 return SWIG_OK;
3251 } else {
3252 long v = 0;
3253 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3254 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3255 return res;
3256 }
3257 }
3258
3259
3260 class wxPyGridCellRenderer : public wxGridCellRenderer
3261 {
3262 public:
3263 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3264
3265 // Implement Python callback aware virtual methods
3266 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3267 wxDC& dc, const wxRect& rect,
3268 int row, int col, bool isSelected) {
3269 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3270 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3271 PyObject* go = wxPyMake_wxObject(&grid,false);
3272 PyObject* dco = wxPyMake_wxObject(&dc,false);
3273 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3274 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3275
3276 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3277 row, col, isSelected));
3278 Py_DECREF(go);
3279 Py_DECREF(ao);
3280 Py_DECREF(dco);
3281 Py_DECREF(ro);
3282 }
3283 wxPyEndBlockThreads(blocked);
3284 }
3285
3286 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3287 int row, int col) {
3288 wxSize rval;
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3291 PyObject* ro;
3292 wxSize* ptr;
3293 PyObject* go = wxPyMake_wxObject(&grid,false);
3294 PyObject* dco = wxPyMake_wxObject(&dc,false);
3295 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3296
3297 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3298 go, ao, dco,
3299 row, col));
3300 Py_DECREF(go);
3301 Py_DECREF(ao);
3302 Py_DECREF(dco);
3303
3304 if (ro) {
3305 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3306 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3307 rval = *ptr;
3308 }
3309 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3310 PyObject* o1 = PySequence_GetItem(ro, 0);
3311 PyObject* o2 = PySequence_GetItem(ro, 1);
3312 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3313 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3314 else
3315 PyErr_SetString(PyExc_TypeError, errmsg);
3316 Py_DECREF(o1);
3317 Py_DECREF(o2);
3318 }
3319 else {
3320 PyErr_SetString(PyExc_TypeError, errmsg);
3321 }
3322 Py_DECREF(ro);
3323 }
3324 }
3325 wxPyEndBlockThreads(blocked);
3326 return rval;
3327 }
3328
3329
3330 wxGridCellRenderer *Clone() const {
3331 wxGridCellRenderer* rval = NULL;
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3334 PyObject* ro;
3335 wxGridCellRenderer* ptr;
3336 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3337 if (ro) {
3338 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3339 rval = ptr;
3340 Py_DECREF(ro);
3341 }
3342 }
3343 wxPyEndBlockThreads(blocked);
3344 return rval;
3345 }
3346
3347 DEC_PYCALLBACK__STRING(SetParameters);
3348
3349 PYPRIVATE;
3350 };
3351
3352 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3353
3354
3355 SWIGINTERN void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
3356 if (!self->GetClientObject())
3357 self->SetClientObject(new wxPyOORClientData(_self));
3358 }
3359
3360 class wxPyGridCellEditor : public wxGridCellEditor
3361 {
3362 public:
3363 wxPyGridCellEditor() : wxGridCellEditor() {}
3364
3365 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3366 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3367 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3368 PyObject* po = wxPyMake_wxObject(parent,false);
3369 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3370
3371 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3372 Py_DECREF(po);
3373 Py_DECREF(eo);
3374 }
3375 wxPyEndBlockThreads(blocked);
3376 }
3377
3378
3379 void BeginEdit(int row, int col, wxGrid* grid) {
3380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3381 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3382 PyObject* go = wxPyMake_wxObject(grid,false);
3383 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3384 Py_DECREF(go);
3385 }
3386 wxPyEndBlockThreads(blocked);
3387 }
3388
3389
3390 bool EndEdit(int row, int col, wxGrid* grid) {
3391 bool rv = false;
3392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3393 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3394 PyObject* go = wxPyMake_wxObject(grid,false);
3395 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3396 Py_DECREF(go);
3397 }
3398 wxPyEndBlockThreads(blocked);
3399 return rv;
3400 }
3401
3402
3403 wxGridCellEditor* Clone() const {
3404 wxGridCellEditor* rval = NULL;
3405 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3406 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3407 PyObject* ro;
3408 wxGridCellEditor* ptr;
3409 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3410 if (ro) {
3411 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3412 rval = ptr;
3413 Py_DECREF(ro);
3414 }
3415 }
3416 wxPyEndBlockThreads(blocked);
3417 return rval;
3418 }
3419
3420
3421 void Show(bool show, wxGridCellAttr *attr) {
3422 bool found;
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3425 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3426 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3427 Py_DECREF(ao);
3428 }
3429 wxPyEndBlockThreads(blocked);
3430 if (! found)
3431 wxGridCellEditor::Show(show, attr);
3432 }
3433
3434
3435 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3436 bool found;
3437 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3438 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3439 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3440 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3441
3442 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3443
3444 Py_DECREF(ro);
3445 Py_DECREF(ao);
3446 }
3447 wxPyEndBlockThreads(blocked);
3448 if (! found)
3449 wxGridCellEditor::PaintBackground(rectCell, attr);
3450 }
3451
3452
3453 DEC_PYCALLBACK___pure(Reset);
3454 DEC_PYCALLBACK__constany(SetSize, wxRect);
3455 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3456 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3457 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3458 DEC_PYCALLBACK__(StartingClick);
3459 DEC_PYCALLBACK__(Destroy);
3460 DEC_PYCALLBACK__STRING(SetParameters);
3461 DEC_PYCALLBACK_STRING__constpure(GetValue);
3462
3463 PYPRIVATE;
3464 };
3465
3466
3467 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3468 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3469 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3470 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3471 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3472 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3473 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3474 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3475 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3476
3477
3478 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3479 if (!self->GetClientObject())
3480 self->SetClientObject(new wxPyOORClientData(_self));
3481 }
3482 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3483 if (!self->GetClientObject())
3484 self->SetClientObject(new wxPyOORClientData(_self));
3485 }
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3489 {
3490 long v = 0;
3491 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3492 return SWIG_TypeError;
3493 }
3494 else if (val)
3495 *val = (unsigned long)v;
3496 return SWIG_OK;
3497 }
3498
3499
3500 SWIGINTERNINLINE int
3501 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3502 {
3503 unsigned long v;
3504 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3505 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3506 return res;
3507 }
3508
3509
3510 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3511 {
3512 public:
3513 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3514
3515 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3516 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3517 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3518 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3519
3520 PYPRIVATE;
3521 };
3522
3523 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3524 if (!self->GetClientObject())
3525 self->SetClientObject(new wxPyOORClientData(_self));
3526 }
3527
3528 #define SWIG_From_double PyFloat_FromDouble
3529
3530
3531 SWIGINTERN int
3532 SWIG_AsVal_double (PyObject *obj, double* val)
3533 {
3534 if (PyNumber_Check(obj)) {
3535 if (val) *val = PyFloat_AsDouble(obj);
3536 return SWIG_OK;
3537 }
3538 return SWIG_TypeError;
3539 }
3540
3541
3542 class wxPyGridTableBase : public wxGridTableBase
3543 {
3544 public:
3545 wxPyGridTableBase() : wxGridTableBase() {}
3546
3547 PYCALLBACK_INT__pure(GetNumberRows);
3548 PYCALLBACK_INT__pure(GetNumberCols);
3549 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3550 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3551 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3552 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3553 PYCALLBACK__(wxGridTableBase, Clear);
3554 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3555 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3556 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3557 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3558 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3559 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3560 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3561 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3562 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3563 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3564 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3565 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3566 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3567 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3568 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3569
3570
3571 wxString GetValue(int row, int col) {
3572 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3573 wxString rval;
3574 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3575 PyObject* ro;
3576 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3577 if (ro) {
3578 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3579 PyObject* old = ro;
3580 ro = PyObject_Str(ro);
3581 Py_DECREF(old);
3582 }
3583 rval = Py2wxString(ro);
3584 Py_DECREF(ro);
3585 }
3586 }
3587 wxPyEndBlockThreads(blocked);
3588 return rval;
3589 }
3590
3591 void SetValue(int row, int col, const wxString& val) {
3592 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3593 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3594 PyObject* s = wx2PyString(val);
3595 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3596 Py_DECREF(s);
3597 }
3598 wxPyEndBlockThreads(blocked);
3599 }
3600
3601
3602 // Map the Get/Set methods for the standard non-string types to
3603 // the GetValue and SetValue python methods.
3604 long GetValueAsLong( int row, int col ) {
3605 long rval = 0;
3606 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3607 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3608 PyObject* ro;
3609 PyObject* num;
3610 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3611 if (ro && PyNumber_Check(ro)) {
3612 num = PyNumber_Int(ro);
3613 if (num) {
3614 rval = PyInt_AsLong(num);
3615 Py_DECREF(num);
3616 }
3617 Py_DECREF(ro);
3618 }
3619 }
3620 wxPyEndBlockThreads(blocked);
3621 return rval;
3622 }
3623
3624 double GetValueAsDouble( int row, int col ) {
3625 double rval = 0.0;
3626 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3627 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3628 PyObject* ro;
3629 PyObject* num;
3630 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3631 if (ro && PyNumber_Check(ro)) {
3632 num = PyNumber_Float(ro);
3633 if (num) {
3634 rval = PyFloat_AsDouble(num);
3635 Py_DECREF(num);
3636 }
3637 Py_DECREF(ro);
3638 }
3639 }
3640 wxPyEndBlockThreads(blocked);
3641 return rval;
3642 }
3643
3644 bool GetValueAsBool( int row, int col ) {
3645 return (bool)GetValueAsLong(row, col);
3646 }
3647
3648 void SetValueAsLong( int row, int col, long value ) {
3649 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3650 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3651 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3652 }
3653 wxPyEndBlockThreads(blocked);
3654 }
3655
3656 void SetValueAsDouble( int row, int col, double value ) {
3657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3658 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3659 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3660 }
3661 wxPyEndBlockThreads(blocked);
3662 }
3663
3664 void SetValueAsBool( int row, int col, bool value ) {
3665 SetValueAsLong( row, col, (long)value );
3666 }
3667
3668
3669 PYPRIVATE;
3670 };
3671
3672 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3673
3674 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3675
3676 if (source == Py_None) {
3677 **obj = wxGridCellCoords(-1,-1);
3678 return true;
3679 }
3680
3681 // If source is an object instance then it may already be the right type
3682 if (wxPySwigInstance_Check(source)) {
3683 wxGridCellCoords* ptr;
3684 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3685 goto error;
3686 *obj = ptr;
3687 return true;
3688 }
3689 // otherwise a 2-tuple of integers is expected
3690 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3691 PyObject* o1 = PySequence_GetItem(source, 0);
3692 PyObject* o2 = PySequence_GetItem(source, 1);
3693 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3694 Py_DECREF(o1);
3695 Py_DECREF(o2);
3696 goto error;
3697 }
3698 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3699 Py_DECREF(o1);
3700 Py_DECREF(o2);
3701 return true;
3702 }
3703
3704 error:
3705 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3706 return false;
3707 }
3708
3709
3710 bool wxGridCellCoords_typecheck(PyObject* source) {
3711 void* ptr;
3712
3713 if (wxPySwigInstance_Check(source) &&
3714 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3715 return true;
3716
3717 PyErr_Clear();
3718 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3719 return true;
3720
3721 return false;
3722 }
3723
3724
3725 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3726 {
3727 PyObject* list = PyList_New(0);
3728 size_t idx;
3729 for (idx = 0; idx < source.GetCount(); idx += 1) {
3730 wxGridCellCoords& coord = source.Item(idx);
3731 PyObject* tup = PyTuple_New(2);
3732 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3733 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3734 PyList_Append(list, tup);
3735 Py_DECREF(tup);
3736 }
3737 return list;
3738 }
3739
3740 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3741 PyObject* tup = PyTuple_New(2);
3742 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3743 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3744 return tup;
3745 }
3746
3747 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3748
3749 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3750 wxGridCellCoords rv;
3751 self->XYToCell(x, y, rv);
3752 return rv;
3753 }
3754 #ifdef __cplusplus
3755 extern "C" {
3756 #endif
3757 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3758 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3759 return 1;
3760 }
3761
3762
3763 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3764 PyObject *pyobj = 0;
3765
3766 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3767 return pyobj;
3768 }
3769
3770
3771 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3772 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3773 return 1;
3774 }
3775
3776
3777 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3778 PyObject *pyobj = 0;
3779
3780 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3781 return pyobj;
3782 }
3783
3784
3785 SWIGINTERN PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj = 0;
3787 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3788 PyObject *arg2 = (PyObject *) 0 ;
3789 void *argp1 = 0 ;
3790 int res1 = 0 ;
3791 PyObject * obj0 = 0 ;
3792 PyObject * obj1 = 0 ;
3793 char * kwnames[] = {
3794 (char *) "self",(char *) "_self", NULL
3795 };
3796
3797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
3799 if (!SWIG_IsOK(res1)) {
3800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
3801 }
3802 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
3803 arg2 = obj1;
3804 {
3805 PyThreadState* __tstate = wxPyBeginAllowThreads();
3806 wxGridCellRenderer__setOORInfo(arg1,arg2);
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 resultobj = SWIG_Py_Void();
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 SWIGINTERN PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj = 0;
3819 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3820 wxString *arg2 = 0 ;
3821 void *argp1 = 0 ;
3822 int res1 = 0 ;
3823 bool temp2 = false ;
3824 PyObject * obj0 = 0 ;
3825 PyObject * obj1 = 0 ;
3826 char * kwnames[] = {
3827 (char *) "self",(char *) "params", NULL
3828 };
3829
3830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
3832 if (!SWIG_IsOK(res1)) {
3833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
3834 }
3835 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
3836 {
3837 arg2 = wxString_in_helper(obj1);
3838 if (arg2 == NULL) SWIG_fail;
3839 temp2 = true;
3840 }
3841 {
3842 PyThreadState* __tstate = wxPyBeginAllowThreads();
3843 (arg1)->SetParameters((wxString const &)*arg2);
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 resultobj = SWIG_Py_Void();
3848 {
3849 if (temp2)
3850 delete arg2;
3851 }
3852 return resultobj;
3853 fail:
3854 {
3855 if (temp2)
3856 delete arg2;
3857 }
3858 return NULL;
3859 }
3860
3861
3862 SWIGINTERN PyObject *_wrap_GridCellRenderer_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3863 PyObject *resultobj = 0;
3864 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3865 void *argp1 = 0 ;
3866 int res1 = 0 ;
3867 PyObject *swig_obj[1] ;
3868
3869 if (!args) SWIG_fail;
3870 swig_obj[0] = args;
3871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
3872 if (!SWIG_IsOK(res1)) {
3873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_IncRef" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
3874 }
3875 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
3876 {
3877 PyThreadState* __tstate = wxPyBeginAllowThreads();
3878 (arg1)->IncRef();
3879 wxPyEndAllowThreads(__tstate);
3880 if (PyErr_Occurred()) SWIG_fail;
3881 }
3882 resultobj = SWIG_Py_Void();
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 SWIGINTERN PyObject *_wrap_GridCellRenderer_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3890 PyObject *resultobj = 0;
3891 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3892 void *argp1 = 0 ;
3893 int res1 = 0 ;
3894 PyObject *swig_obj[1] ;
3895
3896 if (!args) SWIG_fail;
3897 swig_obj[0] = args;
3898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
3899 if (!SWIG_IsOK(res1)) {
3900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_DecRef" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
3901 }
3902 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
3903 {
3904 PyThreadState* __tstate = wxPyBeginAllowThreads();
3905 (arg1)->DecRef();
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 resultobj = SWIG_Py_Void();
3910 return resultobj;
3911 fail:
3912 return NULL;
3913 }
3914
3915
3916 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3917 PyObject *resultobj = 0;
3918 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3919 wxGrid *arg2 = 0 ;
3920 wxGridCellAttr *arg3 = 0 ;
3921 wxDC *arg4 = 0 ;
3922 wxRect *arg5 = 0 ;
3923 int arg6 ;
3924 int arg7 ;
3925 bool arg8 ;
3926 void *argp1 = 0 ;
3927 int res1 = 0 ;
3928 void *argp2 = 0 ;
3929 int res2 = 0 ;
3930 void *argp3 = 0 ;
3931 int res3 = 0 ;
3932 void *argp4 = 0 ;
3933 int res4 = 0 ;
3934 wxRect temp5 ;
3935 int val6 ;
3936 int ecode6 = 0 ;
3937 int val7 ;
3938 int ecode7 = 0 ;
3939 bool val8 ;
3940 int ecode8 = 0 ;
3941 PyObject * obj0 = 0 ;
3942 PyObject * obj1 = 0 ;
3943 PyObject * obj2 = 0 ;
3944 PyObject * obj3 = 0 ;
3945 PyObject * obj4 = 0 ;
3946 PyObject * obj5 = 0 ;
3947 PyObject * obj6 = 0 ;
3948 PyObject * obj7 = 0 ;
3949 char * kwnames[] = {
3950 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
3951 };
3952
3953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
3954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
3955 if (!SWIG_IsOK(res1)) {
3956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
3957 }
3958 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
3959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
3960 if (!SWIG_IsOK(res2)) {
3961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
3962 }
3963 if (!argp2) {
3964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
3965 }
3966 arg2 = reinterpret_cast< wxGrid * >(argp2);
3967 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
3968 if (!SWIG_IsOK(res3)) {
3969 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
3970 }
3971 if (!argp3) {
3972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
3973 }
3974 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
3975 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
3976 if (!SWIG_IsOK(res4)) {
3977 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
3978 }
3979 if (!argp4) {
3980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
3981 }
3982 arg4 = reinterpret_cast< wxDC * >(argp4);
3983 {
3984 arg5 = &temp5;
3985 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
3986 }
3987 ecode6 = SWIG_AsVal_int(obj5, &val6);
3988 if (!SWIG_IsOK(ecode6)) {
3989 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
3990 }
3991 arg6 = static_cast< int >(val6);
3992 ecode7 = SWIG_AsVal_int(obj6, &val7);
3993 if (!SWIG_IsOK(ecode7)) {
3994 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
3995 }
3996 arg7 = static_cast< int >(val7);
3997 ecode8 = SWIG_AsVal_bool(obj7, &val8);
3998 if (!SWIG_IsOK(ecode8)) {
3999 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4000 }
4001 arg8 = static_cast< bool >(val8);
4002 {
4003 PyThreadState* __tstate = wxPyBeginAllowThreads();
4004 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 resultobj = SWIG_Py_Void();
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj = 0;
4017 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4018 wxGrid *arg2 = 0 ;
4019 wxGridCellAttr *arg3 = 0 ;
4020 wxDC *arg4 = 0 ;
4021 int arg5 ;
4022 int arg6 ;
4023 wxSize result;
4024 void *argp1 = 0 ;
4025 int res1 = 0 ;
4026 void *argp2 = 0 ;
4027 int res2 = 0 ;
4028 void *argp3 = 0 ;
4029 int res3 = 0 ;
4030 void *argp4 = 0 ;
4031 int res4 = 0 ;
4032 int val5 ;
4033 int ecode5 = 0 ;
4034 int val6 ;
4035 int ecode6 = 0 ;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 PyObject * obj2 = 0 ;
4039 PyObject * obj3 = 0 ;
4040 PyObject * obj4 = 0 ;
4041 PyObject * obj5 = 0 ;
4042 char * kwnames[] = {
4043 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4044 };
4045
4046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4048 if (!SWIG_IsOK(res1)) {
4049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4050 }
4051 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4053 if (!SWIG_IsOK(res2)) {
4054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4055 }
4056 if (!argp2) {
4057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4058 }
4059 arg2 = reinterpret_cast< wxGrid * >(argp2);
4060 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4061 if (!SWIG_IsOK(res3)) {
4062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4063 }
4064 if (!argp3) {
4065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4066 }
4067 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4068 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4069 if (!SWIG_IsOK(res4)) {
4070 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4071 }
4072 if (!argp4) {
4073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4074 }
4075 arg4 = reinterpret_cast< wxDC * >(argp4);
4076 ecode5 = SWIG_AsVal_int(obj4, &val5);
4077 if (!SWIG_IsOK(ecode5)) {
4078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4079 }
4080 arg5 = static_cast< int >(val5);
4081 ecode6 = SWIG_AsVal_int(obj5, &val6);
4082 if (!SWIG_IsOK(ecode6)) {
4083 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4084 }
4085 arg6 = static_cast< int >(val6);
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4093 return resultobj;
4094 fail:
4095 return NULL;
4096 }
4097
4098
4099 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4100 PyObject *resultobj = 0;
4101 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4102 wxGridCellRenderer *result = 0 ;
4103 void *argp1 = 0 ;
4104 int res1 = 0 ;
4105 PyObject *swig_obj[1] ;
4106
4107 if (!args) SWIG_fail;
4108 swig_obj[0] = args;
4109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4110 if (!SWIG_IsOK(res1)) {
4111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4112 }
4113 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4114 {
4115 PyThreadState* __tstate = wxPyBeginAllowThreads();
4116 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 {
4121 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4122 }
4123 return resultobj;
4124 fail:
4125 return NULL;
4126 }
4127
4128
4129 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4130 PyObject *obj;
4131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4132 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4133 return SWIG_Py_Void();
4134 }
4135
4136 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4137 PyObject *resultobj = 0;
4138 wxPyGridCellRenderer *result = 0 ;
4139
4140 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4141 {
4142 PyThreadState* __tstate = wxPyBeginAllowThreads();
4143 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj = 0;
4156 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4157 PyObject *arg2 = (PyObject *) 0 ;
4158 PyObject *arg3 = (PyObject *) 0 ;
4159 void *argp1 = 0 ;
4160 int res1 = 0 ;
4161 PyObject * obj0 = 0 ;
4162 PyObject * obj1 = 0 ;
4163 PyObject * obj2 = 0 ;
4164 char * kwnames[] = {
4165 (char *) "self",(char *) "self",(char *) "_class", NULL
4166 };
4167
4168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4170 if (!SWIG_IsOK(res1)) {
4171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4172 }
4173 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4174 arg2 = obj1;
4175 arg3 = obj2;
4176 {
4177 PyThreadState* __tstate = wxPyBeginAllowThreads();
4178 (arg1)->_setCallbackInfo(arg2,arg3);
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 resultobj = SWIG_Py_Void();
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj = 0;
4191 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4192 wxString *arg2 = 0 ;
4193 void *argp1 = 0 ;
4194 int res1 = 0 ;
4195 bool temp2 = false ;
4196 PyObject * obj0 = 0 ;
4197 PyObject * obj1 = 0 ;
4198 char * kwnames[] = {
4199 (char *) "self",(char *) "params", NULL
4200 };
4201
4202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4204 if (!SWIG_IsOK(res1)) {
4205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4206 }
4207 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4208 {
4209 arg2 = wxString_in_helper(obj1);
4210 if (arg2 == NULL) SWIG_fail;
4211 temp2 = true;
4212 }
4213 {
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 (arg1)->SetParameters((wxString const &)*arg2);
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 resultobj = SWIG_Py_Void();
4220 {
4221 if (temp2)
4222 delete arg2;
4223 }
4224 return resultobj;
4225 fail:
4226 {
4227 if (temp2)
4228 delete arg2;
4229 }
4230 return NULL;
4231 }
4232
4233
4234 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4235 PyObject *obj;
4236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4237 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4238 return SWIG_Py_Void();
4239 }
4240
4241 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4242 return SWIG_Python_InitShadowInstance(args);
4243 }
4244
4245 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4246 PyObject *resultobj = 0;
4247 wxGridCellStringRenderer *result = 0 ;
4248
4249 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4250 {
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4264 PyObject *obj;
4265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4266 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4267 return SWIG_Py_Void();
4268 }
4269
4270 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4271 return SWIG_Python_InitShadowInstance(args);
4272 }
4273
4274 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4275 PyObject *resultobj = 0;
4276 wxGridCellNumberRenderer *result = 0 ;
4277
4278 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4279 {
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4282 wxPyEndAllowThreads(__tstate);
4283 if (PyErr_Occurred()) SWIG_fail;
4284 }
4285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4286 return resultobj;
4287 fail:
4288 return NULL;
4289 }
4290
4291
4292 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4293 PyObject *obj;
4294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4295 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4296 return SWIG_Py_Void();
4297 }
4298
4299 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 return SWIG_Python_InitShadowInstance(args);
4301 }
4302
4303 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4304 PyObject *resultobj = 0;
4305 int arg1 = (int) -1 ;
4306 int arg2 = (int) -1 ;
4307 wxGridCellFloatRenderer *result = 0 ;
4308 int val1 ;
4309 int ecode1 = 0 ;
4310 int val2 ;
4311 int ecode2 = 0 ;
4312 PyObject * obj0 = 0 ;
4313 PyObject * obj1 = 0 ;
4314 char * kwnames[] = {
4315 (char *) "width",(char *) "precision", NULL
4316 };
4317
4318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4319 if (obj0) {
4320 ecode1 = SWIG_AsVal_int(obj0, &val1);
4321 if (!SWIG_IsOK(ecode1)) {
4322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4323 }
4324 arg1 = static_cast< int >(val1);
4325 }
4326 if (obj1) {
4327 ecode2 = SWIG_AsVal_int(obj1, &val2);
4328 if (!SWIG_IsOK(ecode2)) {
4329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4330 }
4331 arg2 = static_cast< int >(val2);
4332 }
4333 {
4334 PyThreadState* __tstate = wxPyBeginAllowThreads();
4335 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4336 wxPyEndAllowThreads(__tstate);
4337 if (PyErr_Occurred()) SWIG_fail;
4338 }
4339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4347 PyObject *resultobj = 0;
4348 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4349 int result;
4350 void *argp1 = 0 ;
4351 int res1 = 0 ;
4352 PyObject *swig_obj[1] ;
4353
4354 if (!args) SWIG_fail;
4355 swig_obj[0] = args;
4356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4357 if (!SWIG_IsOK(res1)) {
4358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4359 }
4360 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4364 wxPyEndAllowThreads(__tstate);
4365 if (PyErr_Occurred()) SWIG_fail;
4366 }
4367 resultobj = SWIG_From_int(static_cast< int >(result));
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj = 0;
4376 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4377 int arg2 ;
4378 void *argp1 = 0 ;
4379 int res1 = 0 ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char * kwnames[] = {
4385 (char *) "self",(char *) "width", NULL
4386 };
4387
4388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4390 if (!SWIG_IsOK(res1)) {
4391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4392 }
4393 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4394 ecode2 = SWIG_AsVal_int(obj1, &val2);
4395 if (!SWIG_IsOK(ecode2)) {
4396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4397 }
4398 arg2 = static_cast< int >(val2);
4399 {
4400 PyThreadState* __tstate = wxPyBeginAllowThreads();
4401 (arg1)->SetWidth(arg2);
4402 wxPyEndAllowThreads(__tstate);
4403 if (PyErr_Occurred()) SWIG_fail;
4404 }
4405 resultobj = SWIG_Py_Void();
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4415 int result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4425 }
4426 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 resultobj = SWIG_From_int(static_cast< int >(result));
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj = 0;
4442 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4443 int arg2 ;
4444 void *argp1 = 0 ;
4445 int res1 = 0 ;
4446 int val2 ;
4447 int ecode2 = 0 ;
4448 PyObject * obj0 = 0 ;
4449 PyObject * obj1 = 0 ;
4450 char * kwnames[] = {
4451 (char *) "self",(char *) "precision", NULL
4452 };
4453
4454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4458 }
4459 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4460 ecode2 = SWIG_AsVal_int(obj1, &val2);
4461 if (!SWIG_IsOK(ecode2)) {
4462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4463 }
4464 arg2 = static_cast< int >(val2);
4465 {
4466 PyThreadState* __tstate = wxPyBeginAllowThreads();
4467 (arg1)->SetPrecision(arg2);
4468 wxPyEndAllowThreads(__tstate);
4469 if (PyErr_Occurred()) SWIG_fail;
4470 }
4471 resultobj = SWIG_Py_Void();
4472 return resultobj;
4473 fail:
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4479 PyObject *obj;
4480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4481 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4482 return SWIG_Py_Void();
4483 }
4484
4485 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486 return SWIG_Python_InitShadowInstance(args);
4487 }
4488
4489 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4490 PyObject *resultobj = 0;
4491 wxGridCellBoolRenderer *result = 0 ;
4492
4493 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4508 PyObject *obj;
4509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4510 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4511 return SWIG_Py_Void();
4512 }
4513
4514 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 return SWIG_Python_InitShadowInstance(args);
4516 }
4517
4518 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4521 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4522 wxGridCellDateTimeRenderer *result = 0 ;
4523 PyObject * obj0 = 0 ;
4524 PyObject * obj1 = 0 ;
4525 char * kwnames[] = {
4526 (char *) "outformat",(char *) "informat", NULL
4527 };
4528
4529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4530 if (obj0) {
4531 {
4532 wxString* sptr = wxString_in_helper(obj0);
4533 if (sptr == NULL) SWIG_fail;
4534 arg1 = *sptr;
4535 delete sptr;
4536 }
4537 }
4538 if (obj1) {
4539 {
4540 wxString* sptr = wxString_in_helper(obj1);
4541 if (sptr == NULL) SWIG_fail;
4542 arg2 = *sptr;
4543 delete sptr;
4544 }
4545 }
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4553 return resultobj;
4554 fail:
4555 return NULL;
4556 }
4557
4558
4559 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4560 PyObject *obj;
4561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4562 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4563 return SWIG_Py_Void();
4564 }
4565
4566 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567 return SWIG_Python_InitShadowInstance(args);
4568 }
4569
4570 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4571 PyObject *resultobj = 0;
4572 wxString const &arg1_defvalue = wxPyEmptyString ;
4573 wxString *arg1 = (wxString *) &arg1_defvalue ;
4574 wxGridCellEnumRenderer *result = 0 ;
4575 bool temp1 = false ;
4576 PyObject * obj0 = 0 ;
4577 char * kwnames[] = {
4578 (char *) "choices", NULL
4579 };
4580
4581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4582 if (obj0) {
4583 {
4584 arg1 = wxString_in_helper(obj0);
4585 if (arg1 == NULL) SWIG_fail;
4586 temp1 = true;
4587 }
4588 }
4589 {
4590 PyThreadState* __tstate = wxPyBeginAllowThreads();
4591 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4592 wxPyEndAllowThreads(__tstate);
4593 if (PyErr_Occurred()) SWIG_fail;
4594 }
4595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4596 {
4597 if (temp1)
4598 delete arg1;
4599 }
4600 return resultobj;
4601 fail:
4602 {
4603 if (temp1)
4604 delete arg1;
4605 }
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4611 PyObject *obj;
4612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4613 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4614 return SWIG_Py_Void();
4615 }
4616
4617 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4618 return SWIG_Python_InitShadowInstance(args);
4619 }
4620
4621 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 PyObject *resultobj = 0;
4623 wxGridCellAutoWrapStringRenderer *result = 0 ;
4624
4625 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4626 {
4627 PyThreadState* __tstate = wxPyBeginAllowThreads();
4628 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4629 wxPyEndAllowThreads(__tstate);
4630 if (PyErr_Occurred()) SWIG_fail;
4631 }
4632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4633 return resultobj;
4634 fail:
4635 return NULL;
4636 }
4637
4638
4639 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4640 PyObject *obj;
4641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4642 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4643 return SWIG_Py_Void();
4644 }
4645
4646 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4647 return SWIG_Python_InitShadowInstance(args);
4648 }
4649
4650 SWIGINTERN PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj = 0;
4652 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4653 PyObject *arg2 = (PyObject *) 0 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 PyObject * obj0 = 0 ;
4657 PyObject * obj1 = 0 ;
4658 char * kwnames[] = {
4659 (char *) "self",(char *) "_self", NULL
4660 };
4661
4662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
4663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4664 if (!SWIG_IsOK(res1)) {
4665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4666 }
4667 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4668 arg2 = obj1;
4669 {
4670 PyThreadState* __tstate = wxPyBeginAllowThreads();
4671 wxGridCellEditor__setOORInfo(arg1,arg2);
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_Py_Void();
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4683 PyObject *resultobj = 0;
4684 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4685 bool result;
4686 void *argp1 = 0 ;
4687 int res1 = 0 ;
4688 PyObject *swig_obj[1] ;
4689
4690 if (!args) SWIG_fail;
4691 swig_obj[0] = args;
4692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4693 if (!SWIG_IsOK(res1)) {
4694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4695 }
4696 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4697 {
4698 PyThreadState* __tstate = wxPyBeginAllowThreads();
4699 result = (bool)(arg1)->IsCreated();
4700 wxPyEndAllowThreads(__tstate);
4701 if (PyErr_Occurred()) SWIG_fail;
4702 }
4703 {
4704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4705 }
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4715 wxControl *result = 0 ;
4716 void *argp1 = 0 ;
4717 int res1 = 0 ;
4718 PyObject *swig_obj[1] ;
4719
4720 if (!args) SWIG_fail;
4721 swig_obj[0] = args;
4722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4723 if (!SWIG_IsOK(res1)) {
4724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4725 }
4726 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (wxControl *)(arg1)->GetControl();
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 {
4734 resultobj = wxPyMake_wxObject(result, 0);
4735 }
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4745 wxControl *arg2 = (wxControl *) 0 ;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 void *argp2 = 0 ;
4749 int res2 = 0 ;
4750 PyObject * obj0 = 0 ;
4751 PyObject * obj1 = 0 ;
4752 char * kwnames[] = {
4753 (char *) "self",(char *) "control", NULL
4754 };
4755
4756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4758 if (!SWIG_IsOK(res1)) {
4759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4760 }
4761 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4763 if (!SWIG_IsOK(res2)) {
4764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4765 }
4766 arg2 = reinterpret_cast< wxControl * >(argp2);
4767 {
4768 PyThreadState* __tstate = wxPyBeginAllowThreads();
4769 (arg1)->SetControl(arg2);
4770 wxPyEndAllowThreads(__tstate);
4771 if (PyErr_Occurred()) SWIG_fail;
4772 }
4773 resultobj = SWIG_Py_Void();
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4781 PyObject *resultobj = 0;
4782 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4783 wxGridCellAttr *result = 0 ;
4784 void *argp1 = 0 ;
4785 int res1 = 0 ;
4786 PyObject *swig_obj[1] ;
4787
4788 if (!args) SWIG_fail;
4789 swig_obj[0] = args;
4790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4791 if (!SWIG_IsOK(res1)) {
4792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4793 }
4794 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4795 {
4796 PyThreadState* __tstate = wxPyBeginAllowThreads();
4797 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4798 wxPyEndAllowThreads(__tstate);
4799 if (PyErr_Occurred()) SWIG_fail;
4800 }
4801 {
4802 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4803 }
4804 return resultobj;
4805 fail:
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4811 PyObject *resultobj = 0;
4812 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4813 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 void *argp2 = 0 ;
4817 int res2 = 0 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char * kwnames[] = {
4821 (char *) "self",(char *) "attr", NULL
4822 };
4823
4824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4826 if (!SWIG_IsOK(res1)) {
4827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4828 }
4829 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4831 if (!SWIG_IsOK(res2)) {
4832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4833 }
4834 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 (arg1)->SetCellAttr(arg2);
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_Py_Void();
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4851 wxString *arg2 = 0 ;
4852 void *argp1 = 0 ;
4853 int res1 = 0 ;
4854 bool temp2 = false ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char * kwnames[] = {
4858 (char *) "self",(char *) "params", NULL
4859 };
4860
4861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4863 if (!SWIG_IsOK(res1)) {
4864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4865 }
4866 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4867 {
4868 arg2 = wxString_in_helper(obj1);
4869 if (arg2 == NULL) SWIG_fail;
4870 temp2 = true;
4871 }
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 (arg1)->SetParameters((wxString const &)*arg2);
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_Py_Void();
4879 {
4880 if (temp2)
4881 delete arg2;
4882 }
4883 return resultobj;
4884 fail:
4885 {
4886 if (temp2)
4887 delete arg2;
4888 }
4889 return NULL;
4890 }
4891
4892
4893 SWIGINTERN PyObject *_wrap_GridCellEditor_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4894 PyObject *resultobj = 0;
4895 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 PyObject *swig_obj[1] ;
4899
4900 if (!args) SWIG_fail;
4901 swig_obj[0] = args;
4902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4903 if (!SWIG_IsOK(res1)) {
4904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IncRef" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4905 }
4906 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 (arg1)->IncRef();
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 resultobj = SWIG_Py_Void();
4914 return resultobj;
4915 fail:
4916 return NULL;
4917 }
4918
4919
4920 SWIGINTERN PyObject *_wrap_GridCellEditor_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4921 PyObject *resultobj = 0;
4922 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 PyObject *swig_obj[1] ;
4926
4927 if (!args) SWIG_fail;
4928 swig_obj[0] = args;
4929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4930 if (!SWIG_IsOK(res1)) {
4931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_DecRef" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4932 }
4933 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 (arg1)->DecRef();
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 resultobj = SWIG_Py_Void();
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj = 0;
4949 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4950 wxWindow *arg2 = (wxWindow *) 0 ;
4951 int arg3 ;
4952 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4953 void *argp1 = 0 ;
4954 int res1 = 0 ;
4955 void *argp2 = 0 ;
4956 int res2 = 0 ;
4957 int val3 ;
4958 int ecode3 = 0 ;
4959 void *argp4 = 0 ;
4960 int res4 = 0 ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 PyObject * obj3 = 0 ;
4965 char * kwnames[] = {
4966 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4967 };
4968
4969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4971 if (!SWIG_IsOK(res1)) {
4972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4973 }
4974 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4976 if (!SWIG_IsOK(res2)) {
4977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4978 }
4979 arg2 = reinterpret_cast< wxWindow * >(argp2);
4980 ecode3 = SWIG_AsVal_int(obj2, &val3);
4981 if (!SWIG_IsOK(ecode3)) {
4982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4983 }
4984 arg3 = static_cast< int >(val3);
4985 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4986 if (!SWIG_IsOK(res4)) {
4987 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4988 }
4989 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 (arg1)->Create(arg2,arg3,arg4);
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 resultobj = SWIG_Py_Void();
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = 0;
5005 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5006 int arg2 ;
5007 int arg3 ;
5008 wxGrid *arg4 = (wxGrid *) 0 ;
5009 void *argp1 = 0 ;
5010 int res1 = 0 ;
5011 int val2 ;
5012 int ecode2 = 0 ;
5013 int val3 ;
5014 int ecode3 = 0 ;
5015 void *argp4 = 0 ;
5016 int res4 = 0 ;
5017 PyObject * obj0 = 0 ;
5018 PyObject * obj1 = 0 ;
5019 PyObject * obj2 = 0 ;
5020 PyObject * obj3 = 0 ;
5021 char * kwnames[] = {
5022 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5023 };
5024
5025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5027 if (!SWIG_IsOK(res1)) {
5028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5029 }
5030 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5031 ecode2 = SWIG_AsVal_int(obj1, &val2);
5032 if (!SWIG_IsOK(ecode2)) {
5033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
5034 }
5035 arg2 = static_cast< int >(val2);
5036 ecode3 = SWIG_AsVal_int(obj2, &val3);
5037 if (!SWIG_IsOK(ecode3)) {
5038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
5039 }
5040 arg3 = static_cast< int >(val3);
5041 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5042 if (!SWIG_IsOK(res4)) {
5043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5044 }
5045 arg4 = reinterpret_cast< wxGrid * >(argp4);
5046 {
5047 PyThreadState* __tstate = wxPyBeginAllowThreads();
5048 (arg1)->BeginEdit(arg2,arg3,arg4);
5049 wxPyEndAllowThreads(__tstate);
5050 if (PyErr_Occurred()) SWIG_fail;
5051 }
5052 resultobj = SWIG_Py_Void();
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5062 int arg2 ;
5063 int arg3 ;
5064 wxGrid *arg4 = (wxGrid *) 0 ;
5065 bool result;
5066 void *argp1 = 0 ;
5067 int res1 = 0 ;
5068 int val2 ;
5069 int ecode2 = 0 ;
5070 int val3 ;
5071 int ecode3 = 0 ;
5072 void *argp4 = 0 ;
5073 int res4 = 0 ;
5074 PyObject * obj0 = 0 ;
5075 PyObject * obj1 = 0 ;
5076 PyObject * obj2 = 0 ;
5077 PyObject * obj3 = 0 ;
5078 char * kwnames[] = {
5079 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5080 };
5081
5082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5084 if (!SWIG_IsOK(res1)) {
5085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5086 }
5087 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5088 ecode2 = SWIG_AsVal_int(obj1, &val2);
5089 if (!SWIG_IsOK(ecode2)) {
5090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5091 }
5092 arg2 = static_cast< int >(val2);
5093 ecode3 = SWIG_AsVal_int(obj2, &val3);
5094 if (!SWIG_IsOK(ecode3)) {
5095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5096 }
5097 arg3 = static_cast< int >(val3);
5098 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5099 if (!SWIG_IsOK(res4)) {
5100 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5101 }
5102 arg4 = reinterpret_cast< wxGrid * >(argp4);
5103 {
5104 PyThreadState* __tstate = wxPyBeginAllowThreads();
5105 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5106 wxPyEndAllowThreads(__tstate);
5107 if (PyErr_Occurred()) SWIG_fail;
5108 }
5109 {
5110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5111 }
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *resultobj = 0;
5120 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5121 void *argp1 = 0 ;
5122 int res1 = 0 ;
5123 PyObject *swig_obj[1] ;
5124
5125 if (!args) SWIG_fail;
5126 swig_obj[0] = args;
5127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5128 if (!SWIG_IsOK(res1)) {
5129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5130 }
5131 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 (arg1)->Reset();
5135 wxPyEndAllowThreads(__tstate);
5136 if (PyErr_Occurred()) SWIG_fail;
5137 }
5138 resultobj = SWIG_Py_Void();
5139 return resultobj;
5140 fail:
5141 return NULL;
5142 }
5143
5144
5145 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5146 PyObject *resultobj = 0;
5147 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5148 wxGridCellEditor *result = 0 ;
5149 void *argp1 = 0 ;
5150 int res1 = 0 ;
5151 PyObject *swig_obj[1] ;
5152
5153 if (!args) SWIG_fail;
5154 swig_obj[0] = args;
5155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5156 if (!SWIG_IsOK(res1)) {
5157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5158 }
5159 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 {
5167 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5168 }
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5176 PyObject *resultobj = 0;
5177 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5178 wxRect *arg2 = 0 ;
5179 void *argp1 = 0 ;
5180 int res1 = 0 ;
5181 wxRect temp2 ;
5182 PyObject * obj0 = 0 ;
5183 PyObject * obj1 = 0 ;
5184 char * kwnames[] = {
5185 (char *) "self",(char *) "rect", NULL
5186 };
5187
5188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5190 if (!SWIG_IsOK(res1)) {
5191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5192 }
5193 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5194 {
5195 arg2 = &temp2;
5196 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5197 }
5198 {
5199 PyThreadState* __tstate = wxPyBeginAllowThreads();
5200 (arg1)->SetSize((wxRect const &)*arg2);
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 resultobj = SWIG_Py_Void();
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj = 0;
5213 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5214 bool arg2 ;
5215 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 bool val2 ;
5219 int ecode2 = 0 ;
5220 void *argp3 = 0 ;
5221 int res3 = 0 ;
5222 PyObject * obj0 = 0 ;
5223 PyObject * obj1 = 0 ;
5224 PyObject * obj2 = 0 ;
5225 char * kwnames[] = {
5226 (char *) "self",(char *) "show",(char *) "attr", NULL
5227 };
5228
5229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5231 if (!SWIG_IsOK(res1)) {
5232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5233 }
5234 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5236 if (!SWIG_IsOK(ecode2)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5238 }
5239 arg2 = static_cast< bool >(val2);
5240 if (obj2) {
5241 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5242 if (!SWIG_IsOK(res3)) {
5243 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5244 }
5245 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5246 }
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 (arg1)->Show(arg2,arg3);
5250 wxPyEndAllowThreads(__tstate);
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 resultobj = SWIG_Py_Void();
5254 return resultobj;
5255 fail:
5256 return NULL;
5257 }
5258
5259
5260 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5261 PyObject *resultobj = 0;
5262 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5263 wxRect *arg2 = 0 ;
5264 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5265 void *argp1 = 0 ;
5266 int res1 = 0 ;
5267 wxRect temp2 ;
5268 void *argp3 = 0 ;
5269 int res3 = 0 ;
5270 PyObject * obj0 = 0 ;
5271 PyObject * obj1 = 0 ;
5272 PyObject * obj2 = 0 ;
5273 char * kwnames[] = {
5274 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5275 };
5276
5277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5281 }
5282 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5283 {
5284 arg2 = &temp2;
5285 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5286 }
5287 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5288 if (!SWIG_IsOK(res3)) {
5289 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5290 }
5291 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 resultobj = SWIG_Py_Void();
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5306 PyObject *resultobj = 0;
5307 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5308 wxKeyEvent *arg2 = 0 ;
5309 bool result;
5310 void *argp1 = 0 ;
5311 int res1 = 0 ;
5312 void *argp2 = 0 ;
5313 int res2 = 0 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 char * kwnames[] = {
5317 (char *) "self",(char *) "event", NULL
5318 };
5319
5320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5324 }
5325 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5327 if (!SWIG_IsOK(res2)) {
5328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5329 }
5330 if (!argp2) {
5331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5332 }
5333 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5334 {
5335 PyThreadState* __tstate = wxPyBeginAllowThreads();
5336 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5337 wxPyEndAllowThreads(__tstate);
5338 if (PyErr_Occurred()) SWIG_fail;
5339 }
5340 {
5341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5342 }
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5352 wxKeyEvent *arg2 = 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 void *argp2 = 0 ;
5356 int res2 = 0 ;
5357 PyObject * obj0 = 0 ;
5358 PyObject * obj1 = 0 ;
5359 char * kwnames[] = {
5360 (char *) "self",(char *) "event", NULL
5361 };
5362
5363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5365 if (!SWIG_IsOK(res1)) {
5366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5367 }
5368 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5370 if (!SWIG_IsOK(res2)) {
5371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5372 }
5373 if (!argp2) {
5374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5375 }
5376 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 (arg1)->StartingKey(*arg2);
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 resultobj = SWIG_Py_Void();
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5391 PyObject *resultobj = 0;
5392 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5393 void *argp1 = 0 ;
5394 int res1 = 0 ;
5395 PyObject *swig_obj[1] ;
5396
5397 if (!args) SWIG_fail;
5398 swig_obj[0] = args;
5399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5400 if (!SWIG_IsOK(res1)) {
5401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5402 }
5403 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 (arg1)->StartingClick();
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 resultobj = SWIG_Py_Void();
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5418 PyObject *resultobj = 0;
5419 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5420 wxKeyEvent *arg2 = 0 ;
5421 void *argp1 = 0 ;
5422 int res1 = 0 ;
5423 void *argp2 = 0 ;
5424 int res2 = 0 ;
5425 PyObject * obj0 = 0 ;
5426 PyObject * obj1 = 0 ;
5427 char * kwnames[] = {
5428 (char *) "self",(char *) "event", NULL
5429 };
5430
5431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5435 }
5436 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5438 if (!SWIG_IsOK(res2)) {
5439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5440 }
5441 if (!argp2) {
5442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5443 }
5444 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->HandleReturn(*arg2);
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 resultobj = SWIG_Py_Void();
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5459 PyObject *resultobj = 0;
5460 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5461 void *argp1 = 0 ;
5462 int res1 = 0 ;
5463 PyObject *swig_obj[1] ;
5464
5465 if (!args) SWIG_fail;
5466 swig_obj[0] = args;
5467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5468 if (!SWIG_IsOK(res1)) {
5469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5470 }
5471 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5472 {
5473 PyThreadState* __tstate = wxPyBeginAllowThreads();
5474 (arg1)->Destroy();
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 resultobj = SWIG_Py_Void();
5479 return resultobj;
5480 fail:
5481 return NULL;
5482 }
5483
5484
5485 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5486 PyObject *obj;
5487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5488 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5489 return SWIG_Py_Void();
5490 }
5491
5492 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 wxPyGridCellEditor *result = 0 ;
5495
5496 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5504 return resultobj;
5505 fail:
5506 return NULL;
5507 }
5508
5509
5510 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5511 PyObject *resultobj = 0;
5512 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5513 PyObject *arg2 = (PyObject *) 0 ;
5514 PyObject *arg3 = (PyObject *) 0 ;
5515 void *argp1 = 0 ;
5516 int res1 = 0 ;
5517 PyObject * obj0 = 0 ;
5518 PyObject * obj1 = 0 ;
5519 PyObject * obj2 = 0 ;
5520 char * kwnames[] = {
5521 (char *) "self",(char *) "self",(char *) "_class", NULL
5522 };
5523
5524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5526 if (!SWIG_IsOK(res1)) {
5527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5528 }
5529 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5530 arg2 = obj1;
5531 arg3 = obj2;
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 (arg1)->_setCallbackInfo(arg2,arg3);
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 resultobj = SWIG_Py_Void();
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj = 0;
5547 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5548 wxString *arg2 = 0 ;
5549 void *argp1 = 0 ;
5550 int res1 = 0 ;
5551 bool temp2 = false ;
5552 PyObject * obj0 = 0 ;
5553 PyObject * obj1 = 0 ;
5554 char * kwnames[] = {
5555 (char *) "self",(char *) "params", NULL
5556 };
5557
5558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5560 if (!SWIG_IsOK(res1)) {
5561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5562 }
5563 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5564 {
5565 arg2 = wxString_in_helper(obj1);
5566 if (arg2 == NULL) SWIG_fail;
5567 temp2 = true;
5568 }
5569 {
5570 PyThreadState* __tstate = wxPyBeginAllowThreads();
5571 (arg1)->SetParameters((wxString const &)*arg2);
5572 wxPyEndAllowThreads(__tstate);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 resultobj = SWIG_Py_Void();
5576 {
5577 if (temp2)
5578 delete arg2;
5579 }
5580 return resultobj;
5581 fail:
5582 {
5583 if (temp2)
5584 delete arg2;
5585 }
5586 return NULL;
5587 }
5588
5589
5590 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5591 PyObject *obj;
5592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5593 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5594 return SWIG_Py_Void();
5595 }
5596
5597 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5598 return SWIG_Python_InitShadowInstance(args);
5599 }
5600
5601 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5602 PyObject *resultobj = 0;
5603 wxGridCellTextEditor *result = 0 ;
5604
5605 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5606 {
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5620 PyObject *resultobj = 0;
5621 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5622 wxString result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject *swig_obj[1] ;
5626
5627 if (!args) SWIG_fail;
5628 swig_obj[0] = args;
5629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5632 }
5633 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (arg1)->GetValue();
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 #if wxUSE_UNICODE
5642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5643 #else
5644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5645 #endif
5646 }
5647 return resultobj;
5648 fail:
5649 return NULL;
5650 }
5651
5652
5653 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5654 PyObject *obj;
5655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5656 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5657 return SWIG_Py_Void();
5658 }
5659
5660 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5661 return SWIG_Python_InitShadowInstance(args);
5662 }
5663
5664 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj = 0;
5666 int arg1 = (int) -1 ;
5667 int arg2 = (int) -1 ;
5668 wxGridCellNumberEditor *result = 0 ;
5669 int val1 ;
5670 int ecode1 = 0 ;
5671 int val2 ;
5672 int ecode2 = 0 ;
5673 PyObject * obj0 = 0 ;
5674 PyObject * obj1 = 0 ;
5675 char * kwnames[] = {
5676 (char *) "min",(char *) "max", NULL
5677 };
5678
5679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5680 if (obj0) {
5681 ecode1 = SWIG_AsVal_int(obj0, &val1);
5682 if (!SWIG_IsOK(ecode1)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5684 }
5685 arg1 = static_cast< int >(val1);
5686 }
5687 if (obj1) {
5688 ecode2 = SWIG_AsVal_int(obj1, &val2);
5689 if (!SWIG_IsOK(ecode2)) {
5690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5691 }
5692 arg2 = static_cast< int >(val2);
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5708 PyObject *obj;
5709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5710 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5711 return SWIG_Py_Void();
5712 }
5713
5714 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 return SWIG_Python_InitShadowInstance(args);
5716 }
5717
5718 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj = 0;
5720 int arg1 = (int) -1 ;
5721 int arg2 = (int) -1 ;
5722 wxGridCellFloatEditor *result = 0 ;
5723 int val1 ;
5724 int ecode1 = 0 ;
5725 int val2 ;
5726 int ecode2 = 0 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 char * kwnames[] = {
5730 (char *) "width",(char *) "precision", NULL
5731 };
5732
5733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5734 if (obj0) {
5735 ecode1 = SWIG_AsVal_int(obj0, &val1);
5736 if (!SWIG_IsOK(ecode1)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5738 }
5739 arg1 = static_cast< int >(val1);
5740 }
5741 if (obj1) {
5742 ecode2 = SWIG_AsVal_int(obj1, &val2);
5743 if (!SWIG_IsOK(ecode2)) {
5744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5745 }
5746 arg2 = static_cast< int >(val2);
5747 }
5748 {
5749 PyThreadState* __tstate = wxPyBeginAllowThreads();
5750 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5762 PyObject *obj;
5763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5764 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5765 return SWIG_Py_Void();
5766 }
5767
5768 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5769 return SWIG_Python_InitShadowInstance(args);
5770 }
5771
5772 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5773 PyObject *resultobj = 0;
5774 wxGridCellBoolEditor *result = 0 ;
5775
5776 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791 PyObject *resultobj = 0;
5792 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5793 wxString result;
5794 void *argp1 = 0 ;
5795 int res1 = 0 ;
5796 PyObject *swig_obj[1] ;
5797
5798 if (!args) SWIG_fail;
5799 swig_obj[0] = args;
5800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5801 if (!SWIG_IsOK(res1)) {
5802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5803 }
5804 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 result = (arg1)->GetValue();
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 {
5812 #if wxUSE_UNICODE
5813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5814 #else
5815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5816 #endif
5817 }
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5825 PyObject *obj;
5826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5827 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5828 return SWIG_Py_Void();
5829 }
5830
5831 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5832 return SWIG_Python_InitShadowInstance(args);
5833 }
5834
5835 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5836 PyObject *resultobj = 0;
5837 int arg1 = (int) 0 ;
5838 wxString *arg2 = (wxString *) NULL ;
5839 bool arg3 = (bool) false ;
5840 wxGridCellChoiceEditor *result = 0 ;
5841 bool val3 ;
5842 int ecode3 = 0 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 char * kwnames[] = {
5846 (char *) "choices",(char *) "allowOthers", NULL
5847 };
5848
5849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5850 if (obj0) {
5851 {
5852 arg1 = PyList_Size(obj0);
5853 arg2 = wxString_LIST_helper(obj0);
5854 if (arg2 == NULL) SWIG_fail;
5855 }
5856 }
5857 if (obj1) {
5858 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5859 if (!SWIG_IsOK(ecode3)) {
5860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5861 }
5862 arg3 = static_cast< bool >(val3);
5863 }
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5871 {
5872 if (arg2) delete [] arg2;
5873 }
5874 return resultobj;
5875 fail:
5876 {
5877 if (arg2) delete [] arg2;
5878 }
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5884 PyObject *resultobj = 0;
5885 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5886 wxString result;
5887 void *argp1 = 0 ;
5888 int res1 = 0 ;
5889 PyObject *swig_obj[1] ;
5890
5891 if (!args) SWIG_fail;
5892 swig_obj[0] = args;
5893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5894 if (!SWIG_IsOK(res1)) {
5895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5896 }
5897 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 result = (arg1)->GetValue();
5901 wxPyEndAllowThreads(__tstate);
5902 if (PyErr_Occurred()) SWIG_fail;
5903 }
5904 {
5905 #if wxUSE_UNICODE
5906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5907 #else
5908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5909 #endif
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5918 PyObject *obj;
5919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5920 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5921 return SWIG_Py_Void();
5922 }
5923
5924 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5925 return SWIG_Python_InitShadowInstance(args);
5926 }
5927
5928 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj = 0;
5930 wxString const &arg1_defvalue = wxPyEmptyString ;
5931 wxString *arg1 = (wxString *) &arg1_defvalue ;
5932 wxGridCellEnumEditor *result = 0 ;
5933 bool temp1 = false ;
5934 PyObject * obj0 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "choices", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5940 if (obj0) {
5941 {
5942 arg1 = wxString_in_helper(obj0);
5943 if (arg1 == NULL) SWIG_fail;
5944 temp1 = true;
5945 }
5946 }
5947 {
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5954 {
5955 if (temp1)
5956 delete arg1;
5957 }
5958 return resultobj;
5959 fail:
5960 {
5961 if (temp1)
5962 delete arg1;
5963 }
5964 return NULL;
5965 }
5966
5967
5968 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5969 PyObject *obj;
5970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5971 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5972 return SWIG_Py_Void();
5973 }
5974
5975 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5976 return SWIG_Python_InitShadowInstance(args);
5977 }
5978
5979 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5980 PyObject *resultobj = 0;
5981 wxGridCellAutoWrapStringEditor *result = 0 ;
5982
5983 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5998 PyObject *obj;
5999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6000 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
6001 return SWIG_Py_Void();
6002 }
6003
6004 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6005 return SWIG_Python_InitShadowInstance(args);
6006 }
6007
6008 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj = 0;
6010 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6011 PyObject *arg2 = (PyObject *) 0 ;
6012 void *argp1 = 0 ;
6013 int res1 = 0 ;
6014 PyObject * obj0 = 0 ;
6015 PyObject * obj1 = 0 ;
6016 char * kwnames[] = {
6017 (char *) "self",(char *) "_self", NULL
6018 };
6019
6020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6022 if (!SWIG_IsOK(res1)) {
6023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6024 }
6025 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6026 arg2 = obj1;
6027 {
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 wxGridCellAttr__setOORInfo(arg1,arg2);
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 resultobj = SWIG_Py_Void();
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj = 0;
6042 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6043 wxGridCellAttr *result = 0 ;
6044 void *argp1 = 0 ;
6045 int res1 = 0 ;
6046 PyObject * obj0 = 0 ;
6047 char * kwnames[] = {
6048 (char *) "attrDefault", NULL
6049 };
6050
6051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6052 if (obj0) {
6053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6054 if (!SWIG_IsOK(res1)) {
6055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6056 }
6057 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 {
6066 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6067 }
6068 return resultobj;
6069 fail:
6070 return NULL;
6071 }
6072
6073
6074 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6075 PyObject *resultobj = 0;
6076 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6077 wxGridCellAttr *result = 0 ;
6078 void *argp1 = 0 ;
6079 int res1 = 0 ;
6080 PyObject *swig_obj[1] ;
6081
6082 if (!args) SWIG_fail;
6083 swig_obj[0] = args;
6084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6085 if (!SWIG_IsOK(res1)) {
6086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6087 }
6088 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6089 {
6090 PyThreadState* __tstate = wxPyBeginAllowThreads();
6091 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6092 wxPyEndAllowThreads(__tstate);
6093 if (PyErr_Occurred()) SWIG_fail;
6094 }
6095 {
6096 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6097 }
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj = 0;
6106 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6107 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6108 void *argp1 = 0 ;
6109 int res1 = 0 ;
6110 void *argp2 = 0 ;
6111 int res2 = 0 ;
6112 PyObject * obj0 = 0 ;
6113 PyObject * obj1 = 0 ;
6114 char * kwnames[] = {
6115 (char *) "self",(char *) "mergefrom", NULL
6116 };
6117
6118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6120 if (!SWIG_IsOK(res1)) {
6121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6122 }
6123 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6125 if (!SWIG_IsOK(res2)) {
6126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6127 }
6128 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 (arg1)->MergeWith(arg2);
6132 wxPyEndAllowThreads(__tstate);
6133 if (PyErr_Occurred()) SWIG_fail;
6134 }
6135 resultobj = SWIG_Py_Void();
6136 return resultobj;
6137 fail:
6138 return NULL;
6139 }
6140
6141
6142 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6143 PyObject *resultobj = 0;
6144 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6145 void *argp1 = 0 ;
6146 int res1 = 0 ;
6147 PyObject *swig_obj[1] ;
6148
6149 if (!args) SWIG_fail;
6150 swig_obj[0] = args;
6151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6152 if (!SWIG_IsOK(res1)) {
6153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6154 }
6155 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6156 {
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 (arg1)->IncRef();
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_Py_Void();
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6172 void *argp1 = 0 ;
6173 int res1 = 0 ;
6174 PyObject *swig_obj[1] ;
6175
6176 if (!args) SWIG_fail;
6177 swig_obj[0] = args;
6178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6179 if (!SWIG_IsOK(res1)) {
6180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6181 }
6182 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6183 {
6184 PyThreadState* __tstate = wxPyBeginAllowThreads();
6185 (arg1)->DecRef();
6186 wxPyEndAllowThreads(__tstate);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = SWIG_Py_Void();
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6197 PyObject *resultobj = 0;
6198 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6199 wxColour *arg2 = 0 ;
6200 void *argp1 = 0 ;
6201 int res1 = 0 ;
6202 wxColour temp2 ;
6203 PyObject * obj0 = 0 ;
6204 PyObject * obj1 = 0 ;
6205 char * kwnames[] = {
6206 (char *) "self",(char *) "colText", NULL
6207 };
6208
6209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6211 if (!SWIG_IsOK(res1)) {
6212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6213 }
6214 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6215 {
6216 arg2 = &temp2;
6217 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6218 }
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 (arg1)->SetTextColour((wxColour const &)*arg2);
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_Py_Void();
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6235 wxColour *arg2 = 0 ;
6236 void *argp1 = 0 ;
6237 int res1 = 0 ;
6238 wxColour temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char * kwnames[] = {
6242 (char *) "self",(char *) "colBack", NULL
6243 };
6244
6245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6247 if (!SWIG_IsOK(res1)) {
6248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6249 }
6250 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6251 {
6252 arg2 = &temp2;
6253 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6254 }
6255 {
6256 PyThreadState* __tstate = wxPyBeginAllowThreads();
6257 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 resultobj = SWIG_Py_Void();
6262 return resultobj;
6263 fail:
6264 return NULL;
6265 }
6266
6267
6268 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj = 0;
6270 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6271 wxFont *arg2 = 0 ;
6272 void *argp1 = 0 ;
6273 int res1 = 0 ;
6274 void *argp2 = 0 ;
6275 int res2 = 0 ;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 char * kwnames[] = {
6279 (char *) "self",(char *) "font", NULL
6280 };
6281
6282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6284 if (!SWIG_IsOK(res1)) {
6285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6286 }
6287 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6289 if (!SWIG_IsOK(res2)) {
6290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6291 }
6292 if (!argp2) {
6293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6294 }
6295 arg2 = reinterpret_cast< wxFont * >(argp2);
6296 {
6297 PyThreadState* __tstate = wxPyBeginAllowThreads();
6298 (arg1)->SetFont((wxFont const &)*arg2);
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 resultobj = SWIG_Py_Void();
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj = 0;
6311 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6312 int arg2 ;
6313 int arg3 ;
6314 void *argp1 = 0 ;
6315 int res1 = 0 ;
6316 int val2 ;
6317 int ecode2 = 0 ;
6318 int val3 ;
6319 int ecode3 = 0 ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 PyObject * obj2 = 0 ;
6323 char * kwnames[] = {
6324 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6325 };
6326
6327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6329 if (!SWIG_IsOK(res1)) {
6330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6331 }
6332 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6333 ecode2 = SWIG_AsVal_int(obj1, &val2);
6334 if (!SWIG_IsOK(ecode2)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6336 }
6337 arg2 = static_cast< int >(val2);
6338 ecode3 = SWIG_AsVal_int(obj2, &val3);
6339 if (!SWIG_IsOK(ecode3)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6341 }
6342 arg3 = static_cast< int >(val3);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 (arg1)->SetAlignment(arg2,arg3);
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_Py_Void();
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj = 0;
6358 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6359 int arg2 ;
6360 int arg3 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 int val2 ;
6364 int ecode2 = 0 ;
6365 int val3 ;
6366 int ecode3 = 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370 char * kwnames[] = {
6371 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6372 };
6373
6374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6378 }
6379 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6380 ecode2 = SWIG_AsVal_int(obj1, &val2);
6381 if (!SWIG_IsOK(ecode2)) {
6382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6383 }
6384 arg2 = static_cast< int >(val2);
6385 ecode3 = SWIG_AsVal_int(obj2, &val3);
6386 if (!SWIG_IsOK(ecode3)) {
6387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6388 }
6389 arg3 = static_cast< int >(val3);
6390 {
6391 PyThreadState* __tstate = wxPyBeginAllowThreads();
6392 (arg1)->SetSize(arg2,arg3);
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 resultobj = SWIG_Py_Void();
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj = 0;
6405 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6406 bool arg2 = (bool) true ;
6407 void *argp1 = 0 ;
6408 int res1 = 0 ;
6409 bool val2 ;
6410 int ecode2 = 0 ;
6411 PyObject * obj0 = 0 ;
6412 PyObject * obj1 = 0 ;
6413 char * kwnames[] = {
6414 (char *) "self",(char *) "allow", NULL
6415 };
6416
6417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6419 if (!SWIG_IsOK(res1)) {
6420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6421 }
6422 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6423 if (obj1) {
6424 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6425 if (!SWIG_IsOK(ecode2)) {
6426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6427 }
6428 arg2 = static_cast< bool >(val2);
6429 }
6430 {
6431 PyThreadState* __tstate = wxPyBeginAllowThreads();
6432 (arg1)->SetOverflow(arg2);
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = SWIG_Py_Void();
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj = 0;
6445 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6446 bool arg2 = (bool) true ;
6447 void *argp1 = 0 ;
6448 int res1 = 0 ;
6449 bool val2 ;
6450 int ecode2 = 0 ;
6451 PyObject * obj0 = 0 ;
6452 PyObject * obj1 = 0 ;
6453 char * kwnames[] = {
6454 (char *) "self",(char *) "isReadOnly", NULL
6455 };
6456
6457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6459 if (!SWIG_IsOK(res1)) {
6460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6461 }
6462 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6463 if (obj1) {
6464 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6465 if (!SWIG_IsOK(ecode2)) {
6466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6467 }
6468 arg2 = static_cast< bool >(val2);
6469 }
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 (arg1)->SetReadOnly(arg2);
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 resultobj = SWIG_Py_Void();
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj = 0;
6485 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6486 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6487 void *argp1 = 0 ;
6488 int res1 = 0 ;
6489 void *argp2 = 0 ;
6490 int res2 = 0 ;
6491 PyObject * obj0 = 0 ;
6492 PyObject * obj1 = 0 ;
6493 char * kwnames[] = {
6494 (char *) "self",(char *) "renderer", NULL
6495 };
6496
6497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6499 if (!SWIG_IsOK(res1)) {
6500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6501 }
6502 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6504 if (!SWIG_IsOK(res2)) {
6505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6506 }
6507 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6508 {
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 (arg1)->SetRenderer(arg2);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_Py_Void();
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj = 0;
6523 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6524 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6525 void *argp1 = 0 ;
6526 int res1 = 0 ;
6527 void *argp2 = 0 ;
6528 int res2 = 0 ;
6529 PyObject * obj0 = 0 ;
6530 PyObject * obj1 = 0 ;
6531 char * kwnames[] = {
6532 (char *) "self",(char *) "editor", NULL
6533 };
6534
6535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6539 }
6540 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6542 if (!SWIG_IsOK(res2)) {
6543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6544 }
6545 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6546 {
6547 PyThreadState* __tstate = wxPyBeginAllowThreads();
6548 (arg1)->SetEditor(arg2);
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_Py_Void();
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj = 0;
6561 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6562 wxGridCellAttr::wxAttrKind arg2 ;
6563 void *argp1 = 0 ;
6564 int res1 = 0 ;
6565 int val2 ;
6566 int ecode2 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 char * kwnames[] = {
6570 (char *) "self",(char *) "kind", NULL
6571 };
6572
6573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6575 if (!SWIG_IsOK(res1)) {
6576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6577 }
6578 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6579 ecode2 = SWIG_AsVal_int(obj1, &val2);
6580 if (!SWIG_IsOK(ecode2)) {
6581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6582 }
6583 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 (arg1)->SetKind(arg2);
6587 wxPyEndAllowThreads(__tstate);
6588 if (PyErr_Occurred()) SWIG_fail;
6589 }
6590 resultobj = SWIG_Py_Void();
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6598 PyObject *resultobj = 0;
6599 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6600 bool result;
6601 void *argp1 = 0 ;
6602 int res1 = 0 ;
6603 PyObject *swig_obj[1] ;
6604
6605 if (!args) SWIG_fail;
6606 swig_obj[0] = args;
6607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6608 if (!SWIG_IsOK(res1)) {
6609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6610 }
6611 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6615 wxPyEndAllowThreads(__tstate);
6616 if (PyErr_Occurred()) SWIG_fail;
6617 }
6618 {
6619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6620 }
6621 return resultobj;
6622 fail:
6623 return NULL;
6624 }
6625
6626
6627 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6628 PyObject *resultobj = 0;
6629 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6630 bool result;
6631 void *argp1 = 0 ;
6632 int res1 = 0 ;
6633 PyObject *swig_obj[1] ;
6634
6635 if (!args) SWIG_fail;
6636 swig_obj[0] = args;
6637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6638 if (!SWIG_IsOK(res1)) {
6639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6640 }
6641 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6645 wxPyEndAllowThreads(__tstate);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 {
6649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6650 }
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6658 PyObject *resultobj = 0;
6659 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6660 bool result;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 PyObject *swig_obj[1] ;
6664
6665 if (!args) SWIG_fail;
6666 swig_obj[0] = args;
6667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6668 if (!SWIG_IsOK(res1)) {
6669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6670 }
6671 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 {
6679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6680 }
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6690 bool result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 {
6709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6710 }
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6718 PyObject *resultobj = 0;
6719 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6720 bool result;
6721 void *argp1 = 0 ;
6722 int res1 = 0 ;
6723 PyObject *swig_obj[1] ;
6724
6725 if (!args) SWIG_fail;
6726 swig_obj[0] = args;
6727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6730 }
6731 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 {
6739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6740 }
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6748 PyObject *resultobj = 0;
6749 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6750 bool result;
6751 void *argp1 = 0 ;
6752 int res1 = 0 ;
6753 PyObject *swig_obj[1] ;
6754
6755 if (!args) SWIG_fail;
6756 swig_obj[0] = args;
6757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6758 if (!SWIG_IsOK(res1)) {
6759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6760 }
6761 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 {
6769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6770 }
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6780 bool result;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject *swig_obj[1] ;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6790 }
6791 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 {
6799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6800 }
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6808 PyObject *resultobj = 0;
6809 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6810 bool result;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 PyObject *swig_obj[1] ;
6814
6815 if (!args) SWIG_fail;
6816 swig_obj[0] = args;
6817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6820 }
6821 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 {
6829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6830 }
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6840 wxColour result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6866 PyObject *resultobj = 0;
6867 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6868 wxColour result;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 PyObject *swig_obj[1] ;
6872
6873 if (!args) SWIG_fail;
6874 swig_obj[0] = args;
6875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6878 }
6879 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6880 {
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894 PyObject *resultobj = 0;
6895 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6896 wxFont result;
6897 void *argp1 = 0 ;
6898 int res1 = 0 ;
6899 PyObject *swig_obj[1] ;
6900
6901 if (!args) SWIG_fail;
6902 swig_obj[0] = args;
6903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6904 if (!SWIG_IsOK(res1)) {
6905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6906 }
6907 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 result = ((wxGridCellAttr const *)arg1)->GetFont();
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6922 PyObject *resultobj = 0;
6923 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6924 int *arg2 = (int *) 0 ;
6925 int *arg3 = (int *) 0 ;
6926 void *argp1 = 0 ;
6927 int res1 = 0 ;
6928 int temp2 ;
6929 int res2 = SWIG_TMPOBJ ;
6930 int temp3 ;
6931 int res3 = SWIG_TMPOBJ ;
6932 PyObject *swig_obj[1] ;
6933
6934 arg2 = &temp2;
6935 arg3 = &temp3;
6936 if (!args) SWIG_fail;
6937 swig_obj[0] = args;
6938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6939 if (!SWIG_IsOK(res1)) {
6940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6941 }
6942 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6943 {
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 resultobj = SWIG_Py_Void();
6950 if (SWIG_IsTmpObj(res2)) {
6951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6952 } else {
6953 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6955 }
6956 if (SWIG_IsTmpObj(res3)) {
6957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6958 } else {
6959 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6961 }
6962 return resultobj;
6963 fail:
6964 return NULL;
6965 }
6966
6967
6968 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6969 PyObject *resultobj = 0;
6970 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6971 int *arg2 = (int *) 0 ;
6972 int *arg3 = (int *) 0 ;
6973 void *argp1 = 0 ;
6974 int res1 = 0 ;
6975 int temp2 ;
6976 int res2 = SWIG_TMPOBJ ;
6977 int temp3 ;
6978 int res3 = SWIG_TMPOBJ ;
6979 PyObject *swig_obj[1] ;
6980
6981 arg2 = &temp2;
6982 arg3 = &temp3;
6983 if (!args) SWIG_fail;
6984 swig_obj[0] = args;
6985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6986 if (!SWIG_IsOK(res1)) {
6987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6988 }
6989 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6990 {
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 resultobj = SWIG_Py_Void();
6997 if (SWIG_IsTmpObj(res2)) {
6998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6999 } else {
7000 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7002 }
7003 if (SWIG_IsTmpObj(res3)) {
7004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7005 } else {
7006 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7008 }
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7016 PyObject *resultobj = 0;
7017 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7018 bool result;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 PyObject *swig_obj[1] ;
7022
7023 if (!args) SWIG_fail;
7024 swig_obj[0] = args;
7025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7028 }
7029 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7033 wxPyEndAllowThreads(__tstate);
7034 if (PyErr_Occurred()) SWIG_fail;
7035 }
7036 {
7037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7038 }
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7046 PyObject *resultobj = 0;
7047 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7048 wxGrid *arg2 = (wxGrid *) 0 ;
7049 int arg3 ;
7050 int arg4 ;
7051 wxGridCellRenderer *result = 0 ;
7052 void *argp1 = 0 ;
7053 int res1 = 0 ;
7054 void *argp2 = 0 ;
7055 int res2 = 0 ;
7056 int val3 ;
7057 int ecode3 = 0 ;
7058 int val4 ;
7059 int ecode4 = 0 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 PyObject * obj2 = 0 ;
7063 PyObject * obj3 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7072 }
7073 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7075 if (!SWIG_IsOK(res2)) {
7076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7077 }
7078 arg2 = reinterpret_cast< wxGrid * >(argp2);
7079 ecode3 = SWIG_AsVal_int(obj2, &val3);
7080 if (!SWIG_IsOK(ecode3)) {
7081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7082 }
7083 arg3 = static_cast< int >(val3);
7084 ecode4 = SWIG_AsVal_int(obj3, &val4);
7085 if (!SWIG_IsOK(ecode4)) {
7086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7087 }
7088 arg4 = static_cast< int >(val4);
7089 {
7090 PyThreadState* __tstate = wxPyBeginAllowThreads();
7091 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7092 wxPyEndAllowThreads(__tstate);
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 {
7096 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7097 }
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7105 PyObject *resultobj = 0;
7106 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7107 wxGrid *arg2 = (wxGrid *) 0 ;
7108 int arg3 ;
7109 int arg4 ;
7110 wxGridCellEditor *result = 0 ;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 void *argp2 = 0 ;
7114 int res2 = 0 ;
7115 int val3 ;
7116 int ecode3 = 0 ;
7117 int val4 ;
7118 int ecode4 = 0 ;
7119 PyObject * obj0 = 0 ;
7120 PyObject * obj1 = 0 ;
7121 PyObject * obj2 = 0 ;
7122 PyObject * obj3 = 0 ;
7123 char * kwnames[] = {
7124 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7125 };
7126
7127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7129 if (!SWIG_IsOK(res1)) {
7130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7131 }
7132 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7134 if (!SWIG_IsOK(res2)) {
7135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7136 }
7137 arg2 = reinterpret_cast< wxGrid * >(argp2);
7138 ecode3 = SWIG_AsVal_int(obj2, &val3);
7139 if (!SWIG_IsOK(ecode3)) {
7140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7141 }
7142 arg3 = static_cast< int >(val3);
7143 ecode4 = SWIG_AsVal_int(obj3, &val4);
7144 if (!SWIG_IsOK(ecode4)) {
7145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7146 }
7147 arg4 = static_cast< int >(val4);
7148 {
7149 PyThreadState* __tstate = wxPyBeginAllowThreads();
7150 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 {
7155 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7156 }
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7164 PyObject *resultobj = 0;
7165 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7166 bool result;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 PyObject *swig_obj[1] ;
7170
7171 if (!args) SWIG_fail;
7172 swig_obj[0] = args;
7173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7174 if (!SWIG_IsOK(res1)) {
7175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7176 }
7177 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7181 wxPyEndAllowThreads(__tstate);
7182 if (PyErr_Occurred()) SWIG_fail;
7183 }
7184 {
7185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7186 }
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7194 PyObject *resultobj = 0;
7195 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7196 wxGridCellAttr::wxAttrKind result;
7197 void *argp1 = 0 ;
7198 int res1 = 0 ;
7199 PyObject *swig_obj[1] ;
7200
7201 if (!args) SWIG_fail;
7202 swig_obj[0] = args;
7203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7204 if (!SWIG_IsOK(res1)) {
7205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7206 }
7207 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_From_int(static_cast< int >(result));
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7224 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 void *argp2 = 0 ;
7228 int res2 = 0 ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 char * kwnames[] = {
7232 (char *) "self",(char *) "defAttr", NULL
7233 };
7234
7235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7237 if (!SWIG_IsOK(res1)) {
7238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7239 }
7240 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7242 if (!SWIG_IsOK(res2)) {
7243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7244 }
7245 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 (arg1)->SetDefAttr(arg2);
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_Py_Void();
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7260 PyObject *obj;
7261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7262 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7263 return SWIG_Py_Void();
7264 }
7265
7266 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7267 return SWIG_Python_InitShadowInstance(args);
7268 }
7269
7270 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7271 PyObject *resultobj = 0;
7272 wxGridCellAttrProvider *result = 0 ;
7273
7274 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 {
7282 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7283 }
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7291 PyObject *resultobj = 0;
7292 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7293 PyObject *arg2 = (PyObject *) 0 ;
7294 void *argp1 = 0 ;
7295 int res1 = 0 ;
7296 PyObject * obj0 = 0 ;
7297 PyObject * obj1 = 0 ;
7298 char * kwnames[] = {
7299 (char *) "self",(char *) "_self", NULL
7300 };
7301
7302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7304 if (!SWIG_IsOK(res1)) {
7305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7306 }
7307 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7308 arg2 = obj1;
7309 {
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_Py_Void();
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj = 0;
7324 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7325 int arg2 ;
7326 int arg3 ;
7327 wxGridCellAttr::wxAttrKind arg4 ;
7328 wxGridCellAttr *result = 0 ;
7329 void *argp1 = 0 ;
7330 int res1 = 0 ;
7331 int val2 ;
7332 int ecode2 = 0 ;
7333 int val3 ;
7334 int ecode3 = 0 ;
7335 int val4 ;
7336 int ecode4 = 0 ;
7337 PyObject * obj0 = 0 ;
7338 PyObject * obj1 = 0 ;
7339 PyObject * obj2 = 0 ;
7340 PyObject * obj3 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7349 }
7350 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7351 ecode2 = SWIG_AsVal_int(obj1, &val2);
7352 if (!SWIG_IsOK(ecode2)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7354 }
7355 arg2 = static_cast< int >(val2);
7356 ecode3 = SWIG_AsVal_int(obj2, &val3);
7357 if (!SWIG_IsOK(ecode3)) {
7358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7359 }
7360 arg3 = static_cast< int >(val3);
7361 ecode4 = SWIG_AsVal_int(obj3, &val4);
7362 if (!SWIG_IsOK(ecode4)) {
7363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7364 }
7365 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 {
7373 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7374 }
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7382 PyObject *resultobj = 0;
7383 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7384 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7385 int arg3 ;
7386 int arg4 ;
7387 void *argp1 = 0 ;
7388 int res1 = 0 ;
7389 void *argp2 = 0 ;
7390 int res2 = 0 ;
7391 int val3 ;
7392 int ecode3 = 0 ;
7393 int val4 ;
7394 int ecode4 = 0 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 PyObject * obj2 = 0 ;
7398 PyObject * obj3 = 0 ;
7399 char * kwnames[] = {
7400 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7401 };
7402
7403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7407 }
7408 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7410 if (!SWIG_IsOK(res2)) {
7411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7412 }
7413 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7414 ecode3 = SWIG_AsVal_int(obj2, &val3);
7415 if (!SWIG_IsOK(ecode3)) {
7416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7417 }
7418 arg3 = static_cast< int >(val3);
7419 ecode4 = SWIG_AsVal_int(obj3, &val4);
7420 if (!SWIG_IsOK(ecode4)) {
7421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7422 }
7423 arg4 = static_cast< int >(val4);
7424 {
7425 PyThreadState* __tstate = wxPyBeginAllowThreads();
7426 (arg1)->SetAttr(arg2,arg3,arg4);
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 resultobj = SWIG_Py_Void();
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj = 0;
7439 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7440 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7441 int arg3 ;
7442 void *argp1 = 0 ;
7443 int res1 = 0 ;
7444 void *argp2 = 0 ;
7445 int res2 = 0 ;
7446 int val3 ;
7447 int ecode3 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 PyObject * obj2 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "attr",(char *) "row", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7459 }
7460 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7462 if (!SWIG_IsOK(res2)) {
7463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7464 }
7465 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7466 ecode3 = SWIG_AsVal_int(obj2, &val3);
7467 if (!SWIG_IsOK(ecode3)) {
7468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7469 }
7470 arg3 = static_cast< int >(val3);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 (arg1)->SetRowAttr(arg2,arg3);
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 resultobj = SWIG_Py_Void();
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj = 0;
7486 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7487 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7488 int arg3 ;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 void *argp2 = 0 ;
7492 int res2 = 0 ;
7493 int val3 ;
7494 int ecode3 = 0 ;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 PyObject * obj2 = 0 ;
7498 char * kwnames[] = {
7499 (char *) "self",(char *) "attr",(char *) "col", NULL
7500 };
7501
7502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7504 if (!SWIG_IsOK(res1)) {
7505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7506 }
7507 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7509 if (!SWIG_IsOK(res2)) {
7510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7511 }
7512 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7513 ecode3 = SWIG_AsVal_int(obj2, &val3);
7514 if (!SWIG_IsOK(ecode3)) {
7515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7516 }
7517 arg3 = static_cast< int >(val3);
7518 {
7519 PyThreadState* __tstate = wxPyBeginAllowThreads();
7520 (arg1)->SetColAttr(arg2,arg3);
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 resultobj = SWIG_Py_Void();
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj = 0;
7533 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7534 size_t arg2 ;
7535 int arg3 ;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 size_t val2 ;
7539 int ecode2 = 0 ;
7540 int val3 ;
7541 int ecode3 = 0 ;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 PyObject * obj2 = 0 ;
7545 char * kwnames[] = {
7546 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7547 };
7548
7549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7551 if (!SWIG_IsOK(res1)) {
7552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7553 }
7554 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7555 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7556 if (!SWIG_IsOK(ecode2)) {
7557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7558 }
7559 arg2 = static_cast< size_t >(val2);
7560 ecode3 = SWIG_AsVal_int(obj2, &val3);
7561 if (!SWIG_IsOK(ecode3)) {
7562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7563 }
7564 arg3 = static_cast< int >(val3);
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 (arg1)->UpdateAttrRows(arg2,arg3);
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 resultobj = SWIG_Py_Void();
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7581 size_t arg2 ;
7582 int arg3 ;
7583 void *argp1 = 0 ;
7584 int res1 = 0 ;
7585 size_t val2 ;
7586 int ecode2 = 0 ;
7587 int val3 ;
7588 int ecode3 = 0 ;
7589 PyObject * obj0 = 0 ;
7590 PyObject * obj1 = 0 ;
7591 PyObject * obj2 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7600 }
7601 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7602 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7603 if (!SWIG_IsOK(ecode2)) {
7604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7605 }
7606 arg2 = static_cast< size_t >(val2);
7607 ecode3 = SWIG_AsVal_int(obj2, &val3);
7608 if (!SWIG_IsOK(ecode3)) {
7609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7610 }
7611 arg3 = static_cast< int >(val3);
7612 {
7613 PyThreadState* __tstate = wxPyBeginAllowThreads();
7614 (arg1)->UpdateAttrCols(arg2,arg3);
7615 wxPyEndAllowThreads(__tstate);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 resultobj = SWIG_Py_Void();
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7626 PyObject *obj;
7627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7628 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7629 return SWIG_Py_Void();
7630 }
7631
7632 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 return SWIG_Python_InitShadowInstance(args);
7634 }
7635
7636 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxPyGridCellAttrProvider *result = 0 ;
7639
7640 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj = 0;
7656 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7657 PyObject *arg2 = (PyObject *) 0 ;
7658 PyObject *arg3 = (PyObject *) 0 ;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 PyObject * obj0 = 0 ;
7662 PyObject * obj1 = 0 ;
7663 PyObject * obj2 = 0 ;
7664 char * kwnames[] = {
7665 (char *) "self",(char *) "self",(char *) "_class", NULL
7666 };
7667
7668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7670 if (!SWIG_IsOK(res1)) {
7671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7672 }
7673 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7674 arg2 = obj1;
7675 arg3 = obj2;
7676 {
7677 PyThreadState* __tstate = wxPyBeginAllowThreads();
7678 (arg1)->_setCallbackInfo(arg2,arg3);
7679 wxPyEndAllowThreads(__tstate);
7680 if (PyErr_Occurred()) SWIG_fail;
7681 }
7682 resultobj = SWIG_Py_Void();
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7690 PyObject *resultobj = 0;
7691 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7692 int arg2 ;
7693 int arg3 ;
7694 wxGridCellAttr::wxAttrKind arg4 ;
7695 wxGridCellAttr *result = 0 ;
7696 void *argp1 = 0 ;
7697 int res1 = 0 ;
7698 int val2 ;
7699 int ecode2 = 0 ;
7700 int val3 ;
7701 int ecode3 = 0 ;
7702 int val4 ;
7703 int ecode4 = 0 ;
7704 PyObject * obj0 = 0 ;
7705 PyObject * obj1 = 0 ;
7706 PyObject * obj2 = 0 ;
7707 PyObject * obj3 = 0 ;
7708 char * kwnames[] = {
7709 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7710 };
7711
7712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7714 if (!SWIG_IsOK(res1)) {
7715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7716 }
7717 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7718 ecode2 = SWIG_AsVal_int(obj1, &val2);
7719 if (!SWIG_IsOK(ecode2)) {
7720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7721 }
7722 arg2 = static_cast< int >(val2);
7723 ecode3 = SWIG_AsVal_int(obj2, &val3);
7724 if (!SWIG_IsOK(ecode3)) {
7725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7726 }
7727 arg3 = static_cast< int >(val3);
7728 ecode4 = SWIG_AsVal_int(obj3, &val4);
7729 if (!SWIG_IsOK(ecode4)) {
7730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7731 }
7732 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 {
7740 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7741 }
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7749 PyObject *resultobj = 0;
7750 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7751 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7752 int arg3 ;
7753 int arg4 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 void *argp2 = 0 ;
7757 int res2 = 0 ;
7758 int val3 ;
7759 int ecode3 = 0 ;
7760 int val4 ;
7761 int ecode4 = 0 ;
7762 PyObject * obj0 = 0 ;
7763 PyObject * obj1 = 0 ;
7764 PyObject * obj2 = 0 ;
7765 PyObject * obj3 = 0 ;
7766 char * kwnames[] = {
7767 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7768 };
7769
7770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7772 if (!SWIG_IsOK(res1)) {
7773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7774 }
7775 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7777 if (!SWIG_IsOK(res2)) {
7778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7779 }
7780 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7781 ecode3 = SWIG_AsVal_int(obj2, &val3);
7782 if (!SWIG_IsOK(ecode3)) {
7783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7784 }
7785 arg3 = static_cast< int >(val3);
7786 ecode4 = SWIG_AsVal_int(obj3, &val4);
7787 if (!SWIG_IsOK(ecode4)) {
7788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7789 }
7790 arg4 = static_cast< int >(val4);
7791 {
7792 PyThreadState* __tstate = wxPyBeginAllowThreads();
7793 (arg1)->SetAttr(arg2,arg3,arg4);
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 resultobj = SWIG_Py_Void();
7798 return resultobj;
7799 fail:
7800 return NULL;
7801 }
7802
7803
7804 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj = 0;
7806 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7807 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7808 int arg3 ;
7809 void *argp1 = 0 ;
7810 int res1 = 0 ;
7811 void *argp2 = 0 ;
7812 int res2 = 0 ;
7813 int val3 ;
7814 int ecode3 = 0 ;
7815 PyObject * obj0 = 0 ;
7816 PyObject * obj1 = 0 ;
7817 PyObject * obj2 = 0 ;
7818 char * kwnames[] = {
7819 (char *) "self",(char *) "attr",(char *) "row", NULL
7820 };
7821
7822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7824 if (!SWIG_IsOK(res1)) {
7825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7826 }
7827 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7828 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7829 if (!SWIG_IsOK(res2)) {
7830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7831 }
7832 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7833 ecode3 = SWIG_AsVal_int(obj2, &val3);
7834 if (!SWIG_IsOK(ecode3)) {
7835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7836 }
7837 arg3 = static_cast< int >(val3);
7838 {
7839 PyThreadState* __tstate = wxPyBeginAllowThreads();
7840 (arg1)->SetRowAttr(arg2,arg3);
7841 wxPyEndAllowThreads(__tstate);
7842 if (PyErr_Occurred()) SWIG_fail;
7843 }
7844 resultobj = SWIG_Py_Void();
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7852 PyObject *resultobj = 0;
7853 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7854 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7855 int arg3 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 void *argp2 = 0 ;
7859 int res2 = 0 ;
7860 int val3 ;
7861 int ecode3 = 0 ;
7862 PyObject * obj0 = 0 ;
7863 PyObject * obj1 = 0 ;
7864 PyObject * obj2 = 0 ;
7865 char * kwnames[] = {
7866 (char *) "self",(char *) "attr",(char *) "col", NULL
7867 };
7868
7869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7871 if (!SWIG_IsOK(res1)) {
7872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7873 }
7874 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7876 if (!SWIG_IsOK(res2)) {
7877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7878 }
7879 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7880 ecode3 = SWIG_AsVal_int(obj2, &val3);
7881 if (!SWIG_IsOK(ecode3)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7883 }
7884 arg3 = static_cast< int >(val3);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 (arg1)->SetColAttr(arg2,arg3);
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *obj;
7900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7901 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7902 return SWIG_Py_Void();
7903 }
7904
7905 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7906 return SWIG_Python_InitShadowInstance(args);
7907 }
7908
7909 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7910 PyObject *resultobj = 0;
7911 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7912 PyObject *arg2 = (PyObject *) 0 ;
7913 void *argp1 = 0 ;
7914 int res1 = 0 ;
7915 PyObject * obj0 = 0 ;
7916 PyObject * obj1 = 0 ;
7917 char * kwnames[] = {
7918 (char *) "self",(char *) "_self", NULL
7919 };
7920
7921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7923 if (!SWIG_IsOK(res1)) {
7924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7925 }
7926 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7927 arg2 = obj1;
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 wxGridTableBase__setOORInfo(arg1,arg2);
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_Py_Void();
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7944 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 void *argp2 = 0 ;
7948 int res2 = 0 ;
7949 PyObject * obj0 = 0 ;
7950 PyObject * obj1 = 0 ;
7951 char * kwnames[] = {
7952 (char *) "self",(char *) "attrProvider", NULL
7953 };
7954
7955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7959 }
7960 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7962 if (!SWIG_IsOK(res2)) {
7963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7964 }
7965 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 (arg1)->SetAttrProvider(arg2);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7982 wxGridCellAttrProvider *result = 0 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 PyObject *swig_obj[1] ;
7986
7987 if (!args) SWIG_fail;
7988 swig_obj[0] = args;
7989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7992 }
7993 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 {
8001 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8002 }
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8012 wxGrid *arg2 = (wxGrid *) 0 ;
8013 void *argp1 = 0 ;
8014 int res1 = 0 ;
8015 void *argp2 = 0 ;
8016 int res2 = 0 ;
8017 PyObject * obj0 = 0 ;
8018 PyObject * obj1 = 0 ;
8019 char * kwnames[] = {
8020 (char *) "self",(char *) "grid", NULL
8021 };
8022
8023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8025 if (!SWIG_IsOK(res1)) {
8026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8027 }
8028 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8030 if (!SWIG_IsOK(res2)) {
8031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8032 }
8033 arg2 = reinterpret_cast< wxGrid * >(argp2);
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 (arg1)->SetView(arg2);
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 resultobj = SWIG_Py_Void();
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8050 wxGrid *result = 0 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 PyObject *swig_obj[1] ;
8054
8055 if (!args) SWIG_fail;
8056 swig_obj[0] = args;
8057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8058 if (!SWIG_IsOK(res1)) {
8059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8060 }
8061 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 resultobj = wxPyMake_wxObject(result, (bool)0);
8070 }
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8080 int result;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 PyObject *swig_obj[1] ;
8084
8085 if (!args) SWIG_fail;
8086 swig_obj[0] = args;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8090 }
8091 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8092 {
8093 PyThreadState* __tstate = wxPyBeginAllowThreads();
8094 result = (int)(arg1)->GetNumberRows();
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 resultobj = SWIG_From_int(static_cast< int >(result));
8099 return resultobj;
8100 fail:
8101 return NULL;
8102 }
8103
8104
8105 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8106 PyObject *resultobj = 0;
8107 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8108 int result;
8109 void *argp1 = 0 ;
8110 int res1 = 0 ;
8111 PyObject *swig_obj[1] ;
8112
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8118 }
8119 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 result = (int)(arg1)->GetNumberCols();
8123 wxPyEndAllowThreads(__tstate);
8124 if (PyErr_Occurred()) SWIG_fail;
8125 }
8126 resultobj = SWIG_From_int(static_cast< int >(result));
8127 return resultobj;
8128 fail:
8129 return NULL;
8130 }
8131
8132
8133 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8134 PyObject *resultobj = 0;
8135 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8136 int arg2 ;
8137 int arg3 ;
8138 bool result;
8139 void *argp1 = 0 ;
8140 int res1 = 0 ;
8141 int val2 ;
8142 int ecode2 = 0 ;
8143 int val3 ;
8144 int ecode3 = 0 ;
8145 PyObject * obj0 = 0 ;
8146 PyObject * obj1 = 0 ;
8147 PyObject * obj2 = 0 ;
8148 char * kwnames[] = {
8149 (char *) "self",(char *) "row",(char *) "col", NULL
8150 };
8151
8152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8154 if (!SWIG_IsOK(res1)) {
8155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8156 }
8157 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8158 ecode2 = SWIG_AsVal_int(obj1, &val2);
8159 if (!SWIG_IsOK(ecode2)) {
8160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8161 }
8162 arg2 = static_cast< int >(val2);
8163 ecode3 = SWIG_AsVal_int(obj2, &val3);
8164 if (!SWIG_IsOK(ecode3)) {
8165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8166 }
8167 arg3 = static_cast< int >(val3);
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 {
8175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8176 }
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8184 PyObject *resultobj = 0;
8185 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8186 int arg2 ;
8187 int arg3 ;
8188 wxString result;
8189 void *argp1 = 0 ;
8190 int res1 = 0 ;
8191 int val2 ;
8192 int ecode2 = 0 ;
8193 int val3 ;
8194 int ecode3 = 0 ;
8195 PyObject * obj0 = 0 ;
8196 PyObject * obj1 = 0 ;
8197 PyObject * obj2 = 0 ;
8198 char * kwnames[] = {
8199 (char *) "self",(char *) "row",(char *) "col", NULL
8200 };
8201
8202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8204 if (!SWIG_IsOK(res1)) {
8205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8206 }
8207 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8208 ecode2 = SWIG_AsVal_int(obj1, &val2);
8209 if (!SWIG_IsOK(ecode2)) {
8210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8211 }
8212 arg2 = static_cast< int >(val2);
8213 ecode3 = SWIG_AsVal_int(obj2, &val3);
8214 if (!SWIG_IsOK(ecode3)) {
8215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8216 }
8217 arg3 = static_cast< int >(val3);
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 result = (arg1)->GetValue(arg2,arg3);
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 {
8225 #if wxUSE_UNICODE
8226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8227 #else
8228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8229 #endif
8230 }
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = 0;
8239 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8240 int arg2 ;
8241 int arg3 ;
8242 wxString *arg4 = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 int val2 ;
8246 int ecode2 = 0 ;
8247 int val3 ;
8248 int ecode3 = 0 ;
8249 bool temp4 = false ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 PyObject * obj2 = 0 ;
8253 PyObject * obj3 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8260 if (!SWIG_IsOK(res1)) {
8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8262 }
8263 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8264 ecode2 = SWIG_AsVal_int(obj1, &val2);
8265 if (!SWIG_IsOK(ecode2)) {
8266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8267 }
8268 arg2 = static_cast< int >(val2);
8269 ecode3 = SWIG_AsVal_int(obj2, &val3);
8270 if (!SWIG_IsOK(ecode3)) {
8271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8272 }
8273 arg3 = static_cast< int >(val3);
8274 {
8275 arg4 = wxString_in_helper(obj3);
8276 if (arg4 == NULL) SWIG_fail;
8277 temp4 = true;
8278 }
8279 {
8280 PyThreadState* __tstate = wxPyBeginAllowThreads();
8281 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 resultobj = SWIG_Py_Void();
8286 {
8287 if (temp4)
8288 delete arg4;
8289 }
8290 return resultobj;
8291 fail:
8292 {
8293 if (temp4)
8294 delete arg4;
8295 }
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8303 int arg2 ;
8304 int arg3 ;
8305 wxString result;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 int val2 ;
8309 int ecode2 = 0 ;
8310 int val3 ;
8311 int ecode3 = 0 ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 char * kwnames[] = {
8316 (char *) "self",(char *) "row",(char *) "col", NULL
8317 };
8318
8319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8323 }
8324 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8325 ecode2 = SWIG_AsVal_int(obj1, &val2);
8326 if (!SWIG_IsOK(ecode2)) {
8327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8328 }
8329 arg2 = static_cast< int >(val2);
8330 ecode3 = SWIG_AsVal_int(obj2, &val3);
8331 if (!SWIG_IsOK(ecode3)) {
8332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8333 }
8334 arg3 = static_cast< int >(val3);
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (arg1)->GetTypeName(arg2,arg3);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 {
8342 #if wxUSE_UNICODE
8343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8344 #else
8345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8346 #endif
8347 }
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj = 0;
8356 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8357 int arg2 ;
8358 int arg3 ;
8359 wxString *arg4 = 0 ;
8360 bool result;
8361 void *argp1 = 0 ;
8362 int res1 = 0 ;
8363 int val2 ;
8364 int ecode2 = 0 ;
8365 int val3 ;
8366 int ecode3 = 0 ;
8367 bool temp4 = false ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 PyObject * obj2 = 0 ;
8371 PyObject * obj3 = 0 ;
8372 char * kwnames[] = {
8373 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8374 };
8375
8376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8380 }
8381 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8382 ecode2 = SWIG_AsVal_int(obj1, &val2);
8383 if (!SWIG_IsOK(ecode2)) {
8384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8385 }
8386 arg2 = static_cast< int >(val2);
8387 ecode3 = SWIG_AsVal_int(obj2, &val3);
8388 if (!SWIG_IsOK(ecode3)) {
8389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8390 }
8391 arg3 = static_cast< int >(val3);
8392 {
8393 arg4 = wxString_in_helper(obj3);
8394 if (arg4 == NULL) SWIG_fail;
8395 temp4 = true;
8396 }
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 {
8404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8405 }
8406 {
8407 if (temp4)
8408 delete arg4;
8409 }
8410 return resultobj;
8411 fail:
8412 {
8413 if (temp4)
8414 delete arg4;
8415 }
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj = 0;
8422 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8423 int arg2 ;
8424 int arg3 ;
8425 wxString *arg4 = 0 ;
8426 bool result;
8427 void *argp1 = 0 ;
8428 int res1 = 0 ;
8429 int val2 ;
8430 int ecode2 = 0 ;
8431 int val3 ;
8432 int ecode3 = 0 ;
8433 bool temp4 = false ;
8434 PyObject * obj0 = 0 ;
8435 PyObject * obj1 = 0 ;
8436 PyObject * obj2 = 0 ;
8437 PyObject * obj3 = 0 ;
8438 char * kwnames[] = {
8439 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8440 };
8441
8442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8444 if (!SWIG_IsOK(res1)) {
8445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8446 }
8447 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8448 ecode2 = SWIG_AsVal_int(obj1, &val2);
8449 if (!SWIG_IsOK(ecode2)) {
8450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8451 }
8452 arg2 = static_cast< int >(val2);
8453 ecode3 = SWIG_AsVal_int(obj2, &val3);
8454 if (!SWIG_IsOK(ecode3)) {
8455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8456 }
8457 arg3 = static_cast< int >(val3);
8458 {
8459 arg4 = wxString_in_helper(obj3);
8460 if (arg4 == NULL) SWIG_fail;
8461 temp4 = true;
8462 }
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 {
8470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8471 }
8472 {
8473 if (temp4)
8474 delete arg4;
8475 }
8476 return resultobj;
8477 fail:
8478 {
8479 if (temp4)
8480 delete arg4;
8481 }
8482 return NULL;
8483 }
8484
8485
8486 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8487 PyObject *resultobj = 0;
8488 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8489 int arg2 ;
8490 int arg3 ;
8491 long result;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 int val2 ;
8495 int ecode2 = 0 ;
8496 int val3 ;
8497 int ecode3 = 0 ;
8498 PyObject * obj0 = 0 ;
8499 PyObject * obj1 = 0 ;
8500 PyObject * obj2 = 0 ;
8501 char * kwnames[] = {
8502 (char *) "self",(char *) "row",(char *) "col", NULL
8503 };
8504
8505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8507 if (!SWIG_IsOK(res1)) {
8508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8509 }
8510 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8511 ecode2 = SWIG_AsVal_int(obj1, &val2);
8512 if (!SWIG_IsOK(ecode2)) {
8513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8514 }
8515 arg2 = static_cast< int >(val2);
8516 ecode3 = SWIG_AsVal_int(obj2, &val3);
8517 if (!SWIG_IsOK(ecode3)) {
8518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8519 }
8520 arg3 = static_cast< int >(val3);
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 resultobj = SWIG_From_long(static_cast< long >(result));
8528 return resultobj;
8529 fail:
8530 return NULL;
8531 }
8532
8533
8534 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj = 0;
8536 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8537 int arg2 ;
8538 int arg3 ;
8539 double result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 int val2 ;
8543 int ecode2 = 0 ;
8544 int val3 ;
8545 int ecode3 = 0 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 PyObject * obj2 = 0 ;
8549 char * kwnames[] = {
8550 (char *) "self",(char *) "row",(char *) "col", NULL
8551 };
8552
8553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8557 }
8558 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8559 ecode2 = SWIG_AsVal_int(obj1, &val2);
8560 if (!SWIG_IsOK(ecode2)) {
8561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8562 }
8563 arg2 = static_cast< int >(val2);
8564 ecode3 = SWIG_AsVal_int(obj2, &val3);
8565 if (!SWIG_IsOK(ecode3)) {
8566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8567 }
8568 arg3 = static_cast< int >(val3);
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8572 wxPyEndAllowThreads(__tstate);
8573 if (PyErr_Occurred()) SWIG_fail;
8574 }
8575 resultobj = SWIG_From_double(static_cast< double >(result));
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj = 0;
8584 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8585 int arg2 ;
8586 int arg3 ;
8587 bool result;
8588 void *argp1 = 0 ;
8589 int res1 = 0 ;
8590 int val2 ;
8591 int ecode2 = 0 ;
8592 int val3 ;
8593 int ecode3 = 0 ;
8594 PyObject * obj0 = 0 ;
8595 PyObject * obj1 = 0 ;
8596 PyObject * obj2 = 0 ;
8597 char * kwnames[] = {
8598 (char *) "self",(char *) "row",(char *) "col", NULL
8599 };
8600
8601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8603 if (!SWIG_IsOK(res1)) {
8604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8605 }
8606 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8607 ecode2 = SWIG_AsVal_int(obj1, &val2);
8608 if (!SWIG_IsOK(ecode2)) {
8609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8610 }
8611 arg2 = static_cast< int >(val2);
8612 ecode3 = SWIG_AsVal_int(obj2, &val3);
8613 if (!SWIG_IsOK(ecode3)) {
8614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8615 }
8616 arg3 = static_cast< int >(val3);
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 {
8624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8625 }
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj = 0;
8634 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8635 int arg2 ;
8636 int arg3 ;
8637 long arg4 ;
8638 void *argp1 = 0 ;
8639 int res1 = 0 ;
8640 int val2 ;
8641 int ecode2 = 0 ;
8642 int val3 ;
8643 int ecode3 = 0 ;
8644 long val4 ;
8645 int ecode4 = 0 ;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 PyObject * obj2 = 0 ;
8649 PyObject * obj3 = 0 ;
8650 char * kwnames[] = {
8651 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8652 };
8653
8654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8658 }
8659 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8660 ecode2 = SWIG_AsVal_int(obj1, &val2);
8661 if (!SWIG_IsOK(ecode2)) {
8662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8663 }
8664 arg2 = static_cast< int >(val2);
8665 ecode3 = SWIG_AsVal_int(obj2, &val3);
8666 if (!SWIG_IsOK(ecode3)) {
8667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8668 }
8669 arg3 = static_cast< int >(val3);
8670 ecode4 = SWIG_AsVal_long(obj3, &val4);
8671 if (!SWIG_IsOK(ecode4)) {
8672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8673 }
8674 arg4 = static_cast< long >(val4);
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 resultobj = SWIG_Py_Void();
8682 return resultobj;
8683 fail:
8684 return NULL;
8685 }
8686
8687
8688 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8689 PyObject *resultobj = 0;
8690 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8691 int arg2 ;
8692 int arg3 ;
8693 double arg4 ;
8694 void *argp1 = 0 ;
8695 int res1 = 0 ;
8696 int val2 ;
8697 int ecode2 = 0 ;
8698 int val3 ;
8699 int ecode3 = 0 ;
8700 double val4 ;
8701 int ecode4 = 0 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 PyObject * obj2 = 0 ;
8705 PyObject * obj3 = 0 ;
8706 char * kwnames[] = {
8707 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8708 };
8709
8710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8712 if (!SWIG_IsOK(res1)) {
8713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8714 }
8715 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8716 ecode2 = SWIG_AsVal_int(obj1, &val2);
8717 if (!SWIG_IsOK(ecode2)) {
8718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8719 }
8720 arg2 = static_cast< int >(val2);
8721 ecode3 = SWIG_AsVal_int(obj2, &val3);
8722 if (!SWIG_IsOK(ecode3)) {
8723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8724 }
8725 arg3 = static_cast< int >(val3);
8726 ecode4 = SWIG_AsVal_double(obj3, &val4);
8727 if (!SWIG_IsOK(ecode4)) {
8728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8729 }
8730 arg4 = static_cast< double >(val4);
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_Py_Void();
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8747 int arg2 ;
8748 int arg3 ;
8749 bool arg4 ;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 int val2 ;
8753 int ecode2 = 0 ;
8754 int val3 ;
8755 int ecode3 = 0 ;
8756 bool val4 ;
8757 int ecode4 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 PyObject * obj2 = 0 ;
8761 PyObject * obj3 = 0 ;
8762 char * kwnames[] = {
8763 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8764 };
8765
8766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8770 }
8771 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8772 ecode2 = SWIG_AsVal_int(obj1, &val2);
8773 if (!SWIG_IsOK(ecode2)) {
8774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8775 }
8776 arg2 = static_cast< int >(val2);
8777 ecode3 = SWIG_AsVal_int(obj2, &val3);
8778 if (!SWIG_IsOK(ecode3)) {
8779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8780 }
8781 arg3 = static_cast< int >(val3);
8782 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8783 if (!SWIG_IsOK(ecode4)) {
8784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8785 }
8786 arg4 = static_cast< bool >(val4);
8787 {
8788 PyThreadState* __tstate = wxPyBeginAllowThreads();
8789 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8790 wxPyEndAllowThreads(__tstate);
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 resultobj = SWIG_Py_Void();
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 PyObject *swig_obj[1] ;
8806
8807 if (!args) SWIG_fail;
8808 swig_obj[0] = args;
8809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8812 }
8813 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8814 {
8815 PyThreadState* __tstate = wxPyBeginAllowThreads();
8816 (arg1)->Clear();
8817 wxPyEndAllowThreads(__tstate);
8818 if (PyErr_Occurred()) SWIG_fail;
8819 }
8820 resultobj = SWIG_Py_Void();
8821 return resultobj;
8822 fail:
8823 return NULL;
8824 }
8825
8826
8827 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8828 PyObject *resultobj = 0;
8829 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8830 size_t arg2 = (size_t) 0 ;
8831 size_t arg3 = (size_t) 1 ;
8832 bool result;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 size_t val2 ;
8836 int ecode2 = 0 ;
8837 size_t val3 ;
8838 int ecode3 = 0 ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 PyObject * obj2 = 0 ;
8842 char * kwnames[] = {
8843 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8844 };
8845
8846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8850 }
8851 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8852 if (obj1) {
8853 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8856 }
8857 arg2 = static_cast< size_t >(val2);
8858 }
8859 if (obj2) {
8860 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8861 if (!SWIG_IsOK(ecode3)) {
8862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8863 }
8864 arg3 = static_cast< size_t >(val3);
8865 }
8866 {
8867 PyThreadState* __tstate = wxPyBeginAllowThreads();
8868 result = (bool)(arg1)->InsertRows(arg2,arg3);
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 {
8873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8874 }
8875 return resultobj;
8876 fail:
8877 return NULL;
8878 }
8879
8880
8881 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8882 PyObject *resultobj = 0;
8883 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8884 size_t arg2 = (size_t) 1 ;
8885 bool result;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 size_t val2 ;
8889 int ecode2 = 0 ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char * kwnames[] = {
8893 (char *) "self",(char *) "numRows", NULL
8894 };
8895
8896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8898 if (!SWIG_IsOK(res1)) {
8899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8900 }
8901 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8902 if (obj1) {
8903 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8904 if (!SWIG_IsOK(ecode2)) {
8905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8906 }
8907 arg2 = static_cast< size_t >(val2);
8908 }
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 result = (bool)(arg1)->AppendRows(arg2);
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj = 0;
8926 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8927 size_t arg2 = (size_t) 0 ;
8928 size_t arg3 = (size_t) 1 ;
8929 bool result;
8930 void *argp1 = 0 ;
8931 int res1 = 0 ;
8932 size_t val2 ;
8933 int ecode2 = 0 ;
8934 size_t val3 ;
8935 int ecode3 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 PyObject * obj2 = 0 ;
8939 char * kwnames[] = {
8940 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8941 };
8942
8943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8945 if (!SWIG_IsOK(res1)) {
8946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8947 }
8948 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8949 if (obj1) {
8950 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8951 if (!SWIG_IsOK(ecode2)) {
8952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8953 }
8954 arg2 = static_cast< size_t >(val2);
8955 }
8956 if (obj2) {
8957 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8958 if (!SWIG_IsOK(ecode3)) {
8959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8960 }
8961 arg3 = static_cast< size_t >(val3);
8962 }
8963 {
8964 PyThreadState* __tstate = wxPyBeginAllowThreads();
8965 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8966 wxPyEndAllowThreads(__tstate);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 {
8970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8971 }
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj = 0;
8980 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8981 size_t arg2 = (size_t) 0 ;
8982 size_t arg3 = (size_t) 1 ;
8983 bool result;
8984 void *argp1 = 0 ;
8985 int res1 = 0 ;
8986 size_t val2 ;
8987 int ecode2 = 0 ;
8988 size_t val3 ;
8989 int ecode3 = 0 ;
8990 PyObject * obj0 = 0 ;
8991 PyObject * obj1 = 0 ;
8992 PyObject * obj2 = 0 ;
8993 char * kwnames[] = {
8994 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8995 };
8996
8997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9001 }
9002 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9003 if (obj1) {
9004 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9005 if (!SWIG_IsOK(ecode2)) {
9006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9007 }
9008 arg2 = static_cast< size_t >(val2);
9009 }
9010 if (obj2) {
9011 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9012 if (!SWIG_IsOK(ecode3)) {
9013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9014 }
9015 arg3 = static_cast< size_t >(val3);
9016 }
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 result = (bool)(arg1)->InsertCols(arg2,arg3);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 {
9024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9025 }
9026 return resultobj;
9027 fail:
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9033 PyObject *resultobj = 0;
9034 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9035 size_t arg2 = (size_t) 1 ;
9036 bool result;
9037 void *argp1 = 0 ;
9038 int res1 = 0 ;
9039 size_t val2 ;
9040 int ecode2 = 0 ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 char * kwnames[] = {
9044 (char *) "self",(char *) "numCols", NULL
9045 };
9046
9047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9049 if (!SWIG_IsOK(res1)) {
9050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9051 }
9052 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9053 if (obj1) {
9054 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9055 if (!SWIG_IsOK(ecode2)) {
9056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9057 }
9058 arg2 = static_cast< size_t >(val2);
9059 }
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 result = (bool)(arg1)->AppendCols(arg2);
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 {
9067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9068 }
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj = 0;
9077 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9078 size_t arg2 = (size_t) 0 ;
9079 size_t arg3 = (size_t) 1 ;
9080 bool result;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 size_t val2 ;
9084 int ecode2 = 0 ;
9085 size_t val3 ;
9086 int ecode3 = 0 ;
9087 PyObject * obj0 = 0 ;
9088 PyObject * obj1 = 0 ;
9089 PyObject * obj2 = 0 ;
9090 char * kwnames[] = {
9091 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9092 };
9093
9094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9098 }
9099 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9100 if (obj1) {
9101 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9102 if (!SWIG_IsOK(ecode2)) {
9103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9104 }
9105 arg2 = static_cast< size_t >(val2);
9106 }
9107 if (obj2) {
9108 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9109 if (!SWIG_IsOK(ecode3)) {
9110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9111 }
9112 arg3 = static_cast< size_t >(val3);
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9117 wxPyEndAllowThreads(__tstate);
9118 if (PyErr_Occurred()) SWIG_fail;
9119 }
9120 {
9121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9122 }
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj = 0;
9131 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9132 int arg2 ;
9133 wxString result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 int val2 ;
9137 int ecode2 = 0 ;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 char * kwnames[] = {
9141 (char *) "self",(char *) "row", NULL
9142 };
9143
9144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9148 }
9149 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9150 ecode2 = SWIG_AsVal_int(obj1, &val2);
9151 if (!SWIG_IsOK(ecode2)) {
9152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9153 }
9154 arg2 = static_cast< int >(val2);
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (arg1)->GetRowLabelValue(arg2);
9158 wxPyEndAllowThreads(__tstate);
9159 if (PyErr_Occurred()) SWIG_fail;
9160 }
9161 {
9162 #if wxUSE_UNICODE
9163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9164 #else
9165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9166 #endif
9167 }
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj = 0;
9176 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9177 int arg2 ;
9178 wxString result;
9179 void *argp1 = 0 ;
9180 int res1 = 0 ;
9181 int val2 ;
9182 int ecode2 = 0 ;
9183 PyObject * obj0 = 0 ;
9184 PyObject * obj1 = 0 ;
9185 char * kwnames[] = {
9186 (char *) "self",(char *) "col", NULL
9187 };
9188
9189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9191 if (!SWIG_IsOK(res1)) {
9192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9193 }
9194 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9195 ecode2 = SWIG_AsVal_int(obj1, &val2);
9196 if (!SWIG_IsOK(ecode2)) {
9197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9198 }
9199 arg2 = static_cast< int >(val2);
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (arg1)->GetColLabelValue(arg2);
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 #if wxUSE_UNICODE
9208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9209 #else
9210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9211 #endif
9212 }
9213 return resultobj;
9214 fail:
9215 return NULL;
9216 }
9217
9218
9219 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj = 0;
9221 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9222 int arg2 ;
9223 wxString *arg3 = 0 ;
9224 void *argp1 = 0 ;
9225 int res1 = 0 ;
9226 int val2 ;
9227 int ecode2 = 0 ;
9228 bool temp3 = false ;
9229 PyObject * obj0 = 0 ;
9230 PyObject * obj1 = 0 ;
9231 PyObject * obj2 = 0 ;
9232 char * kwnames[] = {
9233 (char *) "self",(char *) "row",(char *) "value", NULL
9234 };
9235
9236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9238 if (!SWIG_IsOK(res1)) {
9239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9240 }
9241 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9242 ecode2 = SWIG_AsVal_int(obj1, &val2);
9243 if (!SWIG_IsOK(ecode2)) {
9244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9245 }
9246 arg2 = static_cast< int >(val2);
9247 {
9248 arg3 = wxString_in_helper(obj2);
9249 if (arg3 == NULL) SWIG_fail;
9250 temp3 = true;
9251 }
9252 {
9253 PyThreadState* __tstate = wxPyBeginAllowThreads();
9254 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9255 wxPyEndAllowThreads(__tstate);
9256 if (PyErr_Occurred()) SWIG_fail;
9257 }
9258 resultobj = SWIG_Py_Void();
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return resultobj;
9264 fail:
9265 {
9266 if (temp3)
9267 delete arg3;
9268 }
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9274 PyObject *resultobj = 0;
9275 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9276 int arg2 ;
9277 wxString *arg3 = 0 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 int val2 ;
9281 int ecode2 = 0 ;
9282 bool temp3 = false ;
9283 PyObject * obj0 = 0 ;
9284 PyObject * obj1 = 0 ;
9285 PyObject * obj2 = 0 ;
9286 char * kwnames[] = {
9287 (char *) "self",(char *) "col",(char *) "value", NULL
9288 };
9289
9290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9294 }
9295 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9296 ecode2 = SWIG_AsVal_int(obj1, &val2);
9297 if (!SWIG_IsOK(ecode2)) {
9298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9299 }
9300 arg2 = static_cast< int >(val2);
9301 {
9302 arg3 = wxString_in_helper(obj2);
9303 if (arg3 == NULL) SWIG_fail;
9304 temp3 = true;
9305 }
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 resultobj = SWIG_Py_Void();
9313 {
9314 if (temp3)
9315 delete arg3;
9316 }
9317 return resultobj;
9318 fail:
9319 {
9320 if (temp3)
9321 delete arg3;
9322 }
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9330 bool result;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9340 }
9341 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (bool)(arg1)->CanHaveAttributes();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 {
9349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9350 }
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj = 0;
9359 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9360 int arg2 ;
9361 int arg3 ;
9362 wxGridCellAttr::wxAttrKind arg4 ;
9363 wxGridCellAttr *result = 0 ;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 int val2 ;
9367 int ecode2 = 0 ;
9368 int val3 ;
9369 int ecode3 = 0 ;
9370 int val4 ;
9371 int ecode4 = 0 ;
9372 PyObject * obj0 = 0 ;
9373 PyObject * obj1 = 0 ;
9374 PyObject * obj2 = 0 ;
9375 PyObject * obj3 = 0 ;
9376 char * kwnames[] = {
9377 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9378 };
9379
9380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9384 }
9385 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9386 ecode2 = SWIG_AsVal_int(obj1, &val2);
9387 if (!SWIG_IsOK(ecode2)) {
9388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9389 }
9390 arg2 = static_cast< int >(val2);
9391 ecode3 = SWIG_AsVal_int(obj2, &val3);
9392 if (!SWIG_IsOK(ecode3)) {
9393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9394 }
9395 arg3 = static_cast< int >(val3);
9396 ecode4 = SWIG_AsVal_int(obj3, &val4);
9397 if (!SWIG_IsOK(ecode4)) {
9398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9399 }
9400 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 {
9408 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9409 }
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj = 0;
9418 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9419 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9420 int arg3 ;
9421 int arg4 ;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 void *argp2 = 0 ;
9425 int res2 = 0 ;
9426 int val3 ;
9427 int ecode3 = 0 ;
9428 int val4 ;
9429 int ecode4 = 0 ;
9430 PyObject * obj0 = 0 ;
9431 PyObject * obj1 = 0 ;
9432 PyObject * obj2 = 0 ;
9433 PyObject * obj3 = 0 ;
9434 char * kwnames[] = {
9435 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9436 };
9437
9438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9442 }
9443 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9445 if (!SWIG_IsOK(res2)) {
9446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9447 }
9448 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9449 ecode3 = SWIG_AsVal_int(obj2, &val3);
9450 if (!SWIG_IsOK(ecode3)) {
9451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9452 }
9453 arg3 = static_cast< int >(val3);
9454 ecode4 = SWIG_AsVal_int(obj3, &val4);
9455 if (!SWIG_IsOK(ecode4)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9457 }
9458 arg4 = static_cast< int >(val4);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 (arg1)->SetAttr(arg2,arg3,arg4);
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 resultobj = SWIG_Py_Void();
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj = 0;
9474 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9475 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9476 int arg3 ;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 void *argp2 = 0 ;
9480 int res2 = 0 ;
9481 int val3 ;
9482 int ecode3 = 0 ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 PyObject * obj2 = 0 ;
9486 char * kwnames[] = {
9487 (char *) "self",(char *) "attr",(char *) "row", NULL
9488 };
9489
9490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9494 }
9495 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9497 if (!SWIG_IsOK(res2)) {
9498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9499 }
9500 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9501 ecode3 = SWIG_AsVal_int(obj2, &val3);
9502 if (!SWIG_IsOK(ecode3)) {
9503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9504 }
9505 arg3 = static_cast< int >(val3);
9506 {
9507 PyThreadState* __tstate = wxPyBeginAllowThreads();
9508 (arg1)->SetRowAttr(arg2,arg3);
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = SWIG_Py_Void();
9513 return resultobj;
9514 fail:
9515 return NULL;
9516 }
9517
9518
9519 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9520 PyObject *resultobj = 0;
9521 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9522 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9523 int arg3 ;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 void *argp2 = 0 ;
9527 int res2 = 0 ;
9528 int val3 ;
9529 int ecode3 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 PyObject * obj2 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "attr",(char *) "col", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9541 }
9542 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9543 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9544 if (!SWIG_IsOK(res2)) {
9545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9546 }
9547 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9548 ecode3 = SWIG_AsVal_int(obj2, &val3);
9549 if (!SWIG_IsOK(ecode3)) {
9550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9551 }
9552 arg3 = static_cast< int >(val3);
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 (arg1)->SetColAttr(arg2,arg3);
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 resultobj = SWIG_Py_Void();
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9567 PyObject *obj;
9568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9569 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9570 return SWIG_Py_Void();
9571 }
9572
9573 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9574 PyObject *resultobj = 0;
9575 wxPyGridTableBase *result = 0 ;
9576
9577 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj = 0;
9593 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9594 PyObject *arg2 = (PyObject *) 0 ;
9595 PyObject *arg3 = (PyObject *) 0 ;
9596 void *argp1 = 0 ;
9597 int res1 = 0 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 PyObject * obj2 = 0 ;
9601 char * kwnames[] = {
9602 (char *) "self",(char *) "self",(char *) "_class", NULL
9603 };
9604
9605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9609 }
9610 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9611 arg2 = obj1;
9612 arg3 = obj2;
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 (arg1)->_setCallbackInfo(arg2,arg3);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_Py_Void();
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9627 PyObject *resultobj = 0;
9628 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 PyObject *swig_obj[1] ;
9632
9633 if (!args) SWIG_fail;
9634 swig_obj[0] = args;
9635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9636 if (!SWIG_IsOK(res1)) {
9637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9638 }
9639 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 wxPyGridTableBase_Destroy(arg1);
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_Py_Void();
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9654 PyObject *obj;
9655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9657 return SWIG_Py_Void();
9658 }
9659
9660 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9661 return SWIG_Python_InitShadowInstance(args);
9662 }
9663
9664 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9665 PyObject *resultobj = 0;
9666 int arg1 = (int) 0 ;
9667 int arg2 = (int) 0 ;
9668 wxGridStringTable *result = 0 ;
9669 int val1 ;
9670 int ecode1 = 0 ;
9671 int val2 ;
9672 int ecode2 = 0 ;
9673 PyObject * obj0 = 0 ;
9674 PyObject * obj1 = 0 ;
9675 char * kwnames[] = {
9676 (char *) "numRows",(char *) "numCols", NULL
9677 };
9678
9679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9680 if (obj0) {
9681 ecode1 = SWIG_AsVal_int(obj0, &val1);
9682 if (!SWIG_IsOK(ecode1)) {
9683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9684 }
9685 arg1 = static_cast< int >(val1);
9686 }
9687 if (obj1) {
9688 ecode2 = SWIG_AsVal_int(obj1, &val2);
9689 if (!SWIG_IsOK(ecode2)) {
9690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9691 }
9692 arg2 = static_cast< int >(val2);
9693 }
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9708 PyObject *obj;
9709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9710 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9711 return SWIG_Py_Void();
9712 }
9713
9714 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9715 return SWIG_Python_InitShadowInstance(args);
9716 }
9717
9718 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9719 PyObject *resultobj = 0;
9720 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9721 int arg2 ;
9722 int arg3 = (int) -1 ;
9723 int arg4 = (int) -1 ;
9724 wxGridTableMessage *result = 0 ;
9725 void *argp1 = 0 ;
9726 int res1 = 0 ;
9727 int val2 ;
9728 int ecode2 = 0 ;
9729 int val3 ;
9730 int ecode3 = 0 ;
9731 int val4 ;
9732 int ecode4 = 0 ;
9733 PyObject * obj0 = 0 ;
9734 PyObject * obj1 = 0 ;
9735 PyObject * obj2 = 0 ;
9736 PyObject * obj3 = 0 ;
9737 char * kwnames[] = {
9738 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9739 };
9740
9741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9743 if (!SWIG_IsOK(res1)) {
9744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9745 }
9746 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9747 ecode2 = SWIG_AsVal_int(obj1, &val2);
9748 if (!SWIG_IsOK(ecode2)) {
9749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9750 }
9751 arg2 = static_cast< int >(val2);
9752 if (obj2) {
9753 ecode3 = SWIG_AsVal_int(obj2, &val3);
9754 if (!SWIG_IsOK(ecode3)) {
9755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9756 }
9757 arg3 = static_cast< int >(val3);
9758 }
9759 if (obj3) {
9760 ecode4 = SWIG_AsVal_int(obj3, &val4);
9761 if (!SWIG_IsOK(ecode4)) {
9762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9763 }
9764 arg4 = static_cast< int >(val4);
9765 }
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780 PyObject *resultobj = 0;
9781 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 PyObject *swig_obj[1] ;
9785
9786 if (!args) SWIG_fail;
9787 swig_obj[0] = args;
9788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9791 }
9792 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 delete arg1;
9796
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 resultobj = SWIG_Py_Void();
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9808 PyObject *resultobj = 0;
9809 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9810 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9811 void *argp1 = 0 ;
9812 int res1 = 0 ;
9813 void *argp2 = 0 ;
9814 int res2 = 0 ;
9815 PyObject * obj0 = 0 ;
9816 PyObject * obj1 = 0 ;
9817 char * kwnames[] = {
9818 (char *) "self",(char *) "table", NULL
9819 };
9820
9821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9823 if (!SWIG_IsOK(res1)) {
9824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9825 }
9826 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9828 if (!SWIG_IsOK(res2)) {
9829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9830 }
9831 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 (arg1)->SetTableObject(arg2);
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 resultobj = SWIG_Py_Void();
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 PyObject *resultobj = 0;
9847 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9848 wxGridTableBase *result = 0 ;
9849 void *argp1 = 0 ;
9850 int res1 = 0 ;
9851 PyObject *swig_obj[1] ;
9852
9853 if (!args) SWIG_fail;
9854 swig_obj[0] = args;
9855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9856 if (!SWIG_IsOK(res1)) {
9857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9858 }
9859 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 {
9867 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9868 }
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9876 PyObject *resultobj = 0;
9877 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9878 int arg2 ;
9879 void *argp1 = 0 ;
9880 int res1 = 0 ;
9881 int val2 ;
9882 int ecode2 = 0 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char * kwnames[] = {
9886 (char *) "self",(char *) "id", NULL
9887 };
9888
9889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9893 }
9894 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9895 ecode2 = SWIG_AsVal_int(obj1, &val2);
9896 if (!SWIG_IsOK(ecode2)) {
9897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9898 }
9899 arg2 = static_cast< int >(val2);
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 (arg1)->SetId(arg2);
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 resultobj = SWIG_Py_Void();
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 PyObject *resultobj = 0;
9915 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9916 int result;
9917 void *argp1 = 0 ;
9918 int res1 = 0 ;
9919 PyObject *swig_obj[1] ;
9920
9921 if (!args) SWIG_fail;
9922 swig_obj[0] = args;
9923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9924 if (!SWIG_IsOK(res1)) {
9925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9926 }
9927 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 result = (int)(arg1)->GetId();
9931 wxPyEndAllowThreads(__tstate);
9932 if (PyErr_Occurred()) SWIG_fail;
9933 }
9934 resultobj = SWIG_From_int(static_cast< int >(result));
9935 return resultobj;
9936 fail:
9937 return NULL;
9938 }
9939
9940
9941 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj = 0;
9943 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9944 int arg2 ;
9945 void *argp1 = 0 ;
9946 int res1 = 0 ;
9947 int val2 ;
9948 int ecode2 = 0 ;
9949 PyObject * obj0 = 0 ;
9950 PyObject * obj1 = 0 ;
9951 char * kwnames[] = {
9952 (char *) "self",(char *) "comInt1", NULL
9953 };
9954
9955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9957 if (!SWIG_IsOK(res1)) {
9958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9959 }
9960 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9961 ecode2 = SWIG_AsVal_int(obj1, &val2);
9962 if (!SWIG_IsOK(ecode2)) {
9963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9964 }
9965 arg2 = static_cast< int >(val2);
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 (arg1)->SetCommandInt(arg2);
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 resultobj = SWIG_Py_Void();
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9980 PyObject *resultobj = 0;
9981 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9982 int result;
9983 void *argp1 = 0 ;
9984 int res1 = 0 ;
9985 PyObject *swig_obj[1] ;
9986
9987 if (!args) SWIG_fail;
9988 swig_obj[0] = args;
9989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9992 }
9993 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 result = (int)(arg1)->GetCommandInt();
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 resultobj = SWIG_From_int(static_cast< int >(result));
10001 return resultobj;
10002 fail:
10003 return NULL;
10004 }
10005
10006
10007 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10008 PyObject *resultobj = 0;
10009 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10010 int arg2 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 int val2 ;
10014 int ecode2 = 0 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 char * kwnames[] = {
10018 (char *) "self",(char *) "comInt2", NULL
10019 };
10020
10021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10025 }
10026 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10027 ecode2 = SWIG_AsVal_int(obj1, &val2);
10028 if (!SWIG_IsOK(ecode2)) {
10029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10030 }
10031 arg2 = static_cast< int >(val2);
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 (arg1)->SetCommandInt2(arg2);
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_Py_Void();
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10046 PyObject *resultobj = 0;
10047 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10048 int result;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 PyObject *swig_obj[1] ;
10052
10053 if (!args) SWIG_fail;
10054 swig_obj[0] = args;
10055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10058 }
10059 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10060 {
10061 PyThreadState* __tstate = wxPyBeginAllowThreads();
10062 result = (int)(arg1)->GetCommandInt2();
10063 wxPyEndAllowThreads(__tstate);
10064 if (PyErr_Occurred()) SWIG_fail;
10065 }
10066 resultobj = SWIG_From_int(static_cast< int >(result));
10067 return resultobj;
10068 fail:
10069 return NULL;
10070 }
10071
10072
10073 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10074 PyObject *obj;
10075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10076 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10077 return SWIG_Py_Void();
10078 }
10079
10080 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10081 return SWIG_Python_InitShadowInstance(args);
10082 }
10083
10084 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj = 0;
10086 int arg1 = (int) -1 ;
10087 int arg2 = (int) -1 ;
10088 wxGridCellCoords *result = 0 ;
10089 int val1 ;
10090 int ecode1 = 0 ;
10091 int val2 ;
10092 int ecode2 = 0 ;
10093 PyObject * obj0 = 0 ;
10094 PyObject * obj1 = 0 ;
10095 char * kwnames[] = {
10096 (char *) "r",(char *) "c", NULL
10097 };
10098
10099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10100 if (obj0) {
10101 ecode1 = SWIG_AsVal_int(obj0, &val1);
10102 if (!SWIG_IsOK(ecode1)) {
10103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10104 }
10105 arg1 = static_cast< int >(val1);
10106 }
10107 if (obj1) {
10108 ecode2 = SWIG_AsVal_int(obj1, &val2);
10109 if (!SWIG_IsOK(ecode2)) {
10110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10111 }
10112 arg2 = static_cast< int >(val2);
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10121 return resultobj;
10122 fail:
10123 return NULL;
10124 }
10125
10126
10127 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10128 PyObject *resultobj = 0;
10129 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10130 void *argp1 = 0 ;
10131 int res1 = 0 ;
10132 PyObject *swig_obj[1] ;
10133
10134 if (!args) SWIG_fail;
10135 swig_obj[0] = args;
10136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10137 if (!SWIG_IsOK(res1)) {
10138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10139 }
10140 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 delete arg1;
10144
10145 wxPyEndAllowThreads(__tstate);
10146 if (PyErr_Occurred()) SWIG_fail;
10147 }
10148 resultobj = SWIG_Py_Void();
10149 return resultobj;
10150 fail:
10151 return NULL;
10152 }
10153
10154
10155 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10156 PyObject *resultobj = 0;
10157 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10158 int result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 PyObject *swig_obj[1] ;
10162
10163 if (!args) SWIG_fail;
10164 swig_obj[0] = args;
10165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10166 if (!SWIG_IsOK(res1)) {
10167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10168 }
10169 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10170 {
10171 PyThreadState* __tstate = wxPyBeginAllowThreads();
10172 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10173 wxPyEndAllowThreads(__tstate);
10174 if (PyErr_Occurred()) SWIG_fail;
10175 }
10176 resultobj = SWIG_From_int(static_cast< int >(result));
10177 return resultobj;
10178 fail:
10179 return NULL;
10180 }
10181
10182
10183 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10184 PyObject *resultobj = 0;
10185 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10186 int arg2 ;
10187 void *argp1 = 0 ;
10188 int res1 = 0 ;
10189 int val2 ;
10190 int ecode2 = 0 ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 char * kwnames[] = {
10194 (char *) "self",(char *) "n", NULL
10195 };
10196
10197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10199 if (!SWIG_IsOK(res1)) {
10200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10201 }
10202 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10203 ecode2 = SWIG_AsVal_int(obj1, &val2);
10204 if (!SWIG_IsOK(ecode2)) {
10205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10206 }
10207 arg2 = static_cast< int >(val2);
10208 {
10209 PyThreadState* __tstate = wxPyBeginAllowThreads();
10210 (arg1)->SetRow(arg2);
10211 wxPyEndAllowThreads(__tstate);
10212 if (PyErr_Occurred()) SWIG_fail;
10213 }
10214 resultobj = SWIG_Py_Void();
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10222 PyObject *resultobj = 0;
10223 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10224 int result;
10225 void *argp1 = 0 ;
10226 int res1 = 0 ;
10227 PyObject *swig_obj[1] ;
10228
10229 if (!args) SWIG_fail;
10230 swig_obj[0] = args;
10231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10232 if (!SWIG_IsOK(res1)) {
10233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10234 }
10235 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 resultobj = SWIG_From_int(static_cast< int >(result));
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10252 int arg2 ;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 int val2 ;
10256 int ecode2 = 0 ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "n", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10267 }
10268 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10269 ecode2 = SWIG_AsVal_int(obj1, &val2);
10270 if (!SWIG_IsOK(ecode2)) {
10271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10272 }
10273 arg2 = static_cast< int >(val2);
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 (arg1)->SetCol(arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 resultobj = SWIG_Py_Void();
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = 0;
10289 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10290 int arg2 ;
10291 int arg3 ;
10292 void *argp1 = 0 ;
10293 int res1 = 0 ;
10294 int val2 ;
10295 int ecode2 = 0 ;
10296 int val3 ;
10297 int ecode3 = 0 ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 PyObject * obj2 = 0 ;
10301 char * kwnames[] = {
10302 (char *) "self",(char *) "row",(char *) "col", NULL
10303 };
10304
10305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10307 if (!SWIG_IsOK(res1)) {
10308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10309 }
10310 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10311 ecode2 = SWIG_AsVal_int(obj1, &val2);
10312 if (!SWIG_IsOK(ecode2)) {
10313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10314 }
10315 arg2 = static_cast< int >(val2);
10316 ecode3 = SWIG_AsVal_int(obj2, &val3);
10317 if (!SWIG_IsOK(ecode3)) {
10318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10319 }
10320 arg3 = static_cast< int >(val3);
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 (arg1)->Set(arg2,arg3);
10324 wxPyEndAllowThreads(__tstate);
10325 if (PyErr_Occurred()) SWIG_fail;
10326 }
10327 resultobj = SWIG_Py_Void();
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj = 0;
10336 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10337 wxGridCellCoords *arg2 = 0 ;
10338 bool result;
10339 void *argp1 = 0 ;
10340 int res1 = 0 ;
10341 wxGridCellCoords temp2 ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 char * kwnames[] = {
10345 (char *) "self",(char *) "other", NULL
10346 };
10347
10348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10352 }
10353 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10354 {
10355 arg2 = &temp2;
10356 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
10357 }
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10366 }
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj = 0;
10375 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10376 wxGridCellCoords *arg2 = 0 ;
10377 bool result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 wxGridCellCoords temp2 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 char * kwnames[] = {
10384 (char *) "self",(char *) "other", NULL
10385 };
10386
10387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10391 }
10392 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10393 {
10394 arg2 = &temp2;
10395 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 {
10404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10405 }
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10413 PyObject *resultobj = 0;
10414 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10415 PyObject *result = 0 ;
10416 void *argp1 = 0 ;
10417 int res1 = 0 ;
10418 PyObject *swig_obj[1] ;
10419
10420 if (!args) SWIG_fail;
10421 swig_obj[0] = args;
10422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10423 if (!SWIG_IsOK(res1)) {
10424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10425 }
10426 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10427 {
10428 PyThreadState* __tstate = wxPyBeginAllowThreads();
10429 result = (PyObject *)wxGridCellCoords_Get(arg1);
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 resultobj = result;
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10441 PyObject *obj;
10442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10443 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10444 return SWIG_Py_Void();
10445 }
10446
10447 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10448 return SWIG_Python_InitShadowInstance(args);
10449 }
10450
10451 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10452 PyObject *resultobj = 0;
10453 wxWindow *arg1 = (wxWindow *) 0 ;
10454 int arg2 = (int) -1 ;
10455 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10456 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10457 wxSize const &arg4_defvalue = wxDefaultSize ;
10458 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10459 long arg5 = (long) wxWANTS_CHARS ;
10460 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10461 wxString *arg6 = (wxString *) &arg6_defvalue ;
10462 wxGrid *result = 0 ;
10463 void *argp1 = 0 ;
10464 int res1 = 0 ;
10465 int val2 ;
10466 int ecode2 = 0 ;
10467 wxPoint temp3 ;
10468 wxSize temp4 ;
10469 long val5 ;
10470 int ecode5 = 0 ;
10471 bool temp6 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 PyObject * obj3 = 0 ;
10476 PyObject * obj4 = 0 ;
10477 PyObject * obj5 = 0 ;
10478 char * kwnames[] = {
10479 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10480 };
10481
10482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10484 if (!SWIG_IsOK(res1)) {
10485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10486 }
10487 arg1 = reinterpret_cast< wxWindow * >(argp1);
10488 if (obj1) {
10489 ecode2 = SWIG_AsVal_int(obj1, &val2);
10490 if (!SWIG_IsOK(ecode2)) {
10491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10492 }
10493 arg2 = static_cast< int >(val2);
10494 }
10495 if (obj2) {
10496 {
10497 arg3 = &temp3;
10498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10499 }
10500 }
10501 if (obj3) {
10502 {
10503 arg4 = &temp4;
10504 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10505 }
10506 }
10507 if (obj4) {
10508 ecode5 = SWIG_AsVal_long(obj4, &val5);
10509 if (!SWIG_IsOK(ecode5)) {
10510 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10511 }
10512 arg5 = static_cast< long >(val5);
10513 }
10514 if (obj5) {
10515 {
10516 arg6 = wxString_in_helper(obj5);
10517 if (arg6 == NULL) SWIG_fail;
10518 temp6 = true;
10519 }
10520 }
10521 {
10522 if (!wxPyCheckForApp()) SWIG_fail;
10523 PyThreadState* __tstate = wxPyBeginAllowThreads();
10524 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10529 {
10530 if (temp6)
10531 delete arg6;
10532 }
10533 return resultobj;
10534 fail:
10535 {
10536 if (temp6)
10537 delete arg6;
10538 }
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10544 PyObject *resultobj = 0;
10545 wxGrid *result = 0 ;
10546
10547 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10548 {
10549 if (!wxPyCheckForApp()) SWIG_fail;
10550 PyThreadState* __tstate = wxPyBeginAllowThreads();
10551 result = (wxGrid *)new wxGrid();
10552 wxPyEndAllowThreads(__tstate);
10553 if (PyErr_Occurred()) SWIG_fail;
10554 }
10555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10556 return resultobj;
10557 fail:
10558 return NULL;
10559 }
10560
10561
10562 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10563 PyObject *resultobj = 0;
10564 wxGrid *arg1 = (wxGrid *) 0 ;
10565 wxWindow *arg2 = (wxWindow *) 0 ;
10566 int arg3 = (int) -1 ;
10567 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10568 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10569 wxSize const &arg5_defvalue = wxDefaultSize ;
10570 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10571 long arg6 = (long) wxWANTS_CHARS ;
10572 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10573 wxString *arg7 = (wxString *) &arg7_defvalue ;
10574 bool result;
10575 void *argp1 = 0 ;
10576 int res1 = 0 ;
10577 void *argp2 = 0 ;
10578 int res2 = 0 ;
10579 int val3 ;
10580 int ecode3 = 0 ;
10581 wxPoint temp4 ;
10582 wxSize temp5 ;
10583 long val6 ;
10584 int ecode6 = 0 ;
10585 bool temp7 = false ;
10586 PyObject * obj0 = 0 ;
10587 PyObject * obj1 = 0 ;
10588 PyObject * obj2 = 0 ;
10589 PyObject * obj3 = 0 ;
10590 PyObject * obj4 = 0 ;
10591 PyObject * obj5 = 0 ;
10592 PyObject * obj6 = 0 ;
10593 char * kwnames[] = {
10594 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10595 };
10596
10597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10601 }
10602 arg1 = reinterpret_cast< wxGrid * >(argp1);
10603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10604 if (!SWIG_IsOK(res2)) {
10605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10606 }
10607 arg2 = reinterpret_cast< wxWindow * >(argp2);
10608 if (obj2) {
10609 ecode3 = SWIG_AsVal_int(obj2, &val3);
10610 if (!SWIG_IsOK(ecode3)) {
10611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10612 }
10613 arg3 = static_cast< int >(val3);
10614 }
10615 if (obj3) {
10616 {
10617 arg4 = &temp4;
10618 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10619 }
10620 }
10621 if (obj4) {
10622 {
10623 arg5 = &temp5;
10624 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10625 }
10626 }
10627 if (obj5) {
10628 ecode6 = SWIG_AsVal_long(obj5, &val6);
10629 if (!SWIG_IsOK(ecode6)) {
10630 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10631 }
10632 arg6 = static_cast< long >(val6);
10633 }
10634 if (obj6) {
10635 {
10636 arg7 = wxString_in_helper(obj6);
10637 if (arg7 == NULL) SWIG_fail;
10638 temp7 = true;
10639 }
10640 }
10641 {
10642 PyThreadState* __tstate = wxPyBeginAllowThreads();
10643 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 {
10648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10649 }
10650 {
10651 if (temp7)
10652 delete arg7;
10653 }
10654 return resultobj;
10655 fail:
10656 {
10657 if (temp7)
10658 delete arg7;
10659 }
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj = 0;
10666 wxGrid *arg1 = (wxGrid *) 0 ;
10667 int arg2 ;
10668 int arg3 ;
10669 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10670 bool result;
10671 void *argp1 = 0 ;
10672 int res1 = 0 ;
10673 int val2 ;
10674 int ecode2 = 0 ;
10675 int val3 ;
10676 int ecode3 = 0 ;
10677 int val4 ;
10678 int ecode4 = 0 ;
10679 PyObject * obj0 = 0 ;
10680 PyObject * obj1 = 0 ;
10681 PyObject * obj2 = 0 ;
10682 PyObject * obj3 = 0 ;
10683 char * kwnames[] = {
10684 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10685 };
10686
10687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10689 if (!SWIG_IsOK(res1)) {
10690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10691 }
10692 arg1 = reinterpret_cast< wxGrid * >(argp1);
10693 ecode2 = SWIG_AsVal_int(obj1, &val2);
10694 if (!SWIG_IsOK(ecode2)) {
10695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10696 }
10697 arg2 = static_cast< int >(val2);
10698 ecode3 = SWIG_AsVal_int(obj2, &val3);
10699 if (!SWIG_IsOK(ecode3)) {
10700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10701 }
10702 arg3 = static_cast< int >(val3);
10703 if (obj3) {
10704 ecode4 = SWIG_AsVal_int(obj3, &val4);
10705 if (!SWIG_IsOK(ecode4)) {
10706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10707 }
10708 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10709 }
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10718 }
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10726 PyObject *resultobj = 0;
10727 wxGrid *arg1 = (wxGrid *) 0 ;
10728 WXGRIDSELECTIONMODES arg2 ;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 int val2 ;
10732 int ecode2 = 0 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 char * kwnames[] = {
10736 (char *) "self",(char *) "selmode", NULL
10737 };
10738
10739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10741 if (!SWIG_IsOK(res1)) {
10742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10743 }
10744 arg1 = reinterpret_cast< wxGrid * >(argp1);
10745 ecode2 = SWIG_AsVal_int(obj1, &val2);
10746 if (!SWIG_IsOK(ecode2)) {
10747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10748 }
10749 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->SetSelectionMode(arg2);
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10764 PyObject *resultobj = 0;
10765 wxGrid *arg1 = (wxGrid *) 0 ;
10766 WXGRIDSELECTIONMODES result;
10767 void *argp1 = 0 ;
10768 int res1 = 0 ;
10769 PyObject *swig_obj[1] ;
10770
10771 if (!args) SWIG_fail;
10772 swig_obj[0] = args;
10773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10774 if (!SWIG_IsOK(res1)) {
10775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10776 }
10777 arg1 = reinterpret_cast< wxGrid * >(argp1);
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_From_int(static_cast< int >(result));
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10792 PyObject *resultobj = 0;
10793 wxGrid *arg1 = (wxGrid *) 0 ;
10794 int result;
10795 void *argp1 = 0 ;
10796 int res1 = 0 ;
10797 PyObject *swig_obj[1] ;
10798
10799 if (!args) SWIG_fail;
10800 swig_obj[0] = args;
10801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10802 if (!SWIG_IsOK(res1)) {
10803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10804 }
10805 arg1 = reinterpret_cast< wxGrid * >(argp1);
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = (int)(arg1)->GetNumberRows();
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_From_int(static_cast< int >(result));
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10820 PyObject *resultobj = 0;
10821 wxGrid *arg1 = (wxGrid *) 0 ;
10822 int result;
10823 void *argp1 = 0 ;
10824 int res1 = 0 ;
10825 PyObject *swig_obj[1] ;
10826
10827 if (!args) SWIG_fail;
10828 swig_obj[0] = args;
10829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10830 if (!SWIG_IsOK(res1)) {
10831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10832 }
10833 arg1 = reinterpret_cast< wxGrid * >(argp1);
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (int)(arg1)->GetNumberCols();
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_From_int(static_cast< int >(result));
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxGrid *arg1 = (wxGrid *) 0 ;
10850 wxGridTableMessage *arg2 = 0 ;
10851 bool result;
10852 void *argp1 = 0 ;
10853 int res1 = 0 ;
10854 void *argp2 = 0 ;
10855 int res2 = 0 ;
10856 PyObject * obj0 = 0 ;
10857 PyObject * obj1 = 0 ;
10858 char * kwnames[] = {
10859 (char *) "self",(char *)"arg2", NULL
10860 };
10861
10862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10864 if (!SWIG_IsOK(res1)) {
10865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10866 }
10867 arg1 = reinterpret_cast< wxGrid * >(argp1);
10868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10869 if (!SWIG_IsOK(res2)) {
10870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10871 }
10872 if (!argp2) {
10873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10874 }
10875 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 {
10883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10884 }
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10892 PyObject *resultobj = 0;
10893 wxGrid *arg1 = (wxGrid *) 0 ;
10894 wxGridTableBase *result = 0 ;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 PyObject *swig_obj[1] ;
10898
10899 if (!args) SWIG_fail;
10900 swig_obj[0] = args;
10901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10902 if (!SWIG_IsOK(res1)) {
10903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10904 }
10905 arg1 = reinterpret_cast< wxGrid * >(argp1);
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10914 }
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj = 0;
10923 wxGrid *arg1 = (wxGrid *) 0 ;
10924 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10925 bool arg3 = (bool) false ;
10926 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10927 bool result;
10928 void *argp1 = 0 ;
10929 int res1 = 0 ;
10930 void *argp2 = 0 ;
10931 int res2 = 0 ;
10932 bool val3 ;
10933 int ecode3 = 0 ;
10934 int val4 ;
10935 int ecode4 = 0 ;
10936 PyObject * obj0 = 0 ;
10937 PyObject * obj1 = 0 ;
10938 PyObject * obj2 = 0 ;
10939 PyObject * obj3 = 0 ;
10940 char * kwnames[] = {
10941 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10942 };
10943
10944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10946 if (!SWIG_IsOK(res1)) {
10947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10948 }
10949 arg1 = reinterpret_cast< wxGrid * >(argp1);
10950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
10951 if (!SWIG_IsOK(res2)) {
10952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10953 }
10954 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
10955 if (obj2) {
10956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10957 if (!SWIG_IsOK(ecode3)) {
10958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10959 }
10960 arg3 = static_cast< bool >(val3);
10961 }
10962 if (obj3) {
10963 ecode4 = SWIG_AsVal_int(obj3, &val4);
10964 if (!SWIG_IsOK(ecode4)) {
10965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10966 }
10967 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10968 }
10969 {
10970 PyThreadState* __tstate = wxPyBeginAllowThreads();
10971 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10972 wxPyEndAllowThreads(__tstate);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 {
10976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10977 }
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10985 PyObject *resultobj = 0;
10986 wxGrid *arg1 = (wxGrid *) 0 ;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 PyObject *swig_obj[1] ;
10990
10991 if (!args) SWIG_fail;
10992 swig_obj[0] = args;
10993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10996 }
10997 arg1 = reinterpret_cast< wxGrid * >(argp1);
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 (arg1)->ClearGrid();
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 resultobj = SWIG_Py_Void();
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj = 0;
11013 wxGrid *arg1 = (wxGrid *) 0 ;
11014 int arg2 = (int) 0 ;
11015 int arg3 = (int) 1 ;
11016 bool arg4 = (bool) true ;
11017 bool result;
11018 void *argp1 = 0 ;
11019 int res1 = 0 ;
11020 int val2 ;
11021 int ecode2 = 0 ;
11022 int val3 ;
11023 int ecode3 = 0 ;
11024 bool val4 ;
11025 int ecode4 = 0 ;
11026 PyObject * obj0 = 0 ;
11027 PyObject * obj1 = 0 ;
11028 PyObject * obj2 = 0 ;
11029 PyObject * obj3 = 0 ;
11030 char * kwnames[] = {
11031 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11032 };
11033
11034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11036 if (!SWIG_IsOK(res1)) {
11037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11038 }
11039 arg1 = reinterpret_cast< wxGrid * >(argp1);
11040 if (obj1) {
11041 ecode2 = SWIG_AsVal_int(obj1, &val2);
11042 if (!SWIG_IsOK(ecode2)) {
11043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11044 }
11045 arg2 = static_cast< int >(val2);
11046 }
11047 if (obj2) {
11048 ecode3 = SWIG_AsVal_int(obj2, &val3);
11049 if (!SWIG_IsOK(ecode3)) {
11050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11051 }
11052 arg3 = static_cast< int >(val3);
11053 }
11054 if (obj3) {
11055 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11056 if (!SWIG_IsOK(ecode4)) {
11057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11058 }
11059 arg4 = static_cast< bool >(val4);
11060 }
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11069 }
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11077 PyObject *resultobj = 0;
11078 wxGrid *arg1 = (wxGrid *) 0 ;
11079 int arg2 = (int) 1 ;
11080 bool arg3 = (bool) true ;
11081 bool result;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 int val2 ;
11085 int ecode2 = 0 ;
11086 bool val3 ;
11087 int ecode3 = 0 ;
11088 PyObject * obj0 = 0 ;
11089 PyObject * obj1 = 0 ;
11090 PyObject * obj2 = 0 ;
11091 char * kwnames[] = {
11092 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11093 };
11094
11095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11097 if (!SWIG_IsOK(res1)) {
11098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11099 }
11100 arg1 = reinterpret_cast< wxGrid * >(argp1);
11101 if (obj1) {
11102 ecode2 = SWIG_AsVal_int(obj1, &val2);
11103 if (!SWIG_IsOK(ecode2)) {
11104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11105 }
11106 arg2 = static_cast< int >(val2);
11107 }
11108 if (obj2) {
11109 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11110 if (!SWIG_IsOK(ecode3)) {
11111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11112 }
11113 arg3 = static_cast< bool >(val3);
11114 }
11115 {
11116 PyThreadState* __tstate = wxPyBeginAllowThreads();
11117 result = (bool)(arg1)->AppendRows(arg2,arg3);
11118 wxPyEndAllowThreads(__tstate);
11119 if (PyErr_Occurred()) SWIG_fail;
11120 }
11121 {
11122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11123 }
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj = 0;
11132 wxGrid *arg1 = (wxGrid *) 0 ;
11133 int arg2 = (int) 0 ;
11134 int arg3 = (int) 1 ;
11135 bool arg4 = (bool) true ;
11136 bool result;
11137 void *argp1 = 0 ;
11138 int res1 = 0 ;
11139 int val2 ;
11140 int ecode2 = 0 ;
11141 int val3 ;
11142 int ecode3 = 0 ;
11143 bool val4 ;
11144 int ecode4 = 0 ;
11145 PyObject * obj0 = 0 ;
11146 PyObject * obj1 = 0 ;
11147 PyObject * obj2 = 0 ;
11148 PyObject * obj3 = 0 ;
11149 char * kwnames[] = {
11150 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11151 };
11152
11153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11155 if (!SWIG_IsOK(res1)) {
11156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11157 }
11158 arg1 = reinterpret_cast< wxGrid * >(argp1);
11159 if (obj1) {
11160 ecode2 = SWIG_AsVal_int(obj1, &val2);
11161 if (!SWIG_IsOK(ecode2)) {
11162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11163 }
11164 arg2 = static_cast< int >(val2);
11165 }
11166 if (obj2) {
11167 ecode3 = SWIG_AsVal_int(obj2, &val3);
11168 if (!SWIG_IsOK(ecode3)) {
11169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11170 }
11171 arg3 = static_cast< int >(val3);
11172 }
11173 if (obj3) {
11174 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11175 if (!SWIG_IsOK(ecode4)) {
11176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11177 }
11178 arg4 = static_cast< bool >(val4);
11179 }
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 {
11187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11188 }
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11196 PyObject *resultobj = 0;
11197 wxGrid *arg1 = (wxGrid *) 0 ;
11198 int arg2 = (int) 0 ;
11199 int arg3 = (int) 1 ;
11200 bool arg4 = (bool) true ;
11201 bool result;
11202 void *argp1 = 0 ;
11203 int res1 = 0 ;
11204 int val2 ;
11205 int ecode2 = 0 ;
11206 int val3 ;
11207 int ecode3 = 0 ;
11208 bool val4 ;
11209 int ecode4 = 0 ;
11210 PyObject * obj0 = 0 ;
11211 PyObject * obj1 = 0 ;
11212 PyObject * obj2 = 0 ;
11213 PyObject * obj3 = 0 ;
11214 char * kwnames[] = {
11215 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11216 };
11217
11218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11220 if (!SWIG_IsOK(res1)) {
11221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11222 }
11223 arg1 = reinterpret_cast< wxGrid * >(argp1);
11224 if (obj1) {
11225 ecode2 = SWIG_AsVal_int(obj1, &val2);
11226 if (!SWIG_IsOK(ecode2)) {
11227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11228 }
11229 arg2 = static_cast< int >(val2);
11230 }
11231 if (obj2) {
11232 ecode3 = SWIG_AsVal_int(obj2, &val3);
11233 if (!SWIG_IsOK(ecode3)) {
11234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11235 }
11236 arg3 = static_cast< int >(val3);
11237 }
11238 if (obj3) {
11239 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11240 if (!SWIG_IsOK(ecode4)) {
11241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11242 }
11243 arg4 = static_cast< bool >(val4);
11244 }
11245 {
11246 PyThreadState* __tstate = wxPyBeginAllowThreads();
11247 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11248 wxPyEndAllowThreads(__tstate);
11249 if (PyErr_Occurred()) SWIG_fail;
11250 }
11251 {
11252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11253 }
11254 return resultobj;
11255 fail:
11256 return NULL;
11257 }
11258
11259
11260 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = 0;
11262 wxGrid *arg1 = (wxGrid *) 0 ;
11263 int arg2 = (int) 1 ;
11264 bool arg3 = (bool) true ;
11265 bool result;
11266 void *argp1 = 0 ;
11267 int res1 = 0 ;
11268 int val2 ;
11269 int ecode2 = 0 ;
11270 bool val3 ;
11271 int ecode3 = 0 ;
11272 PyObject * obj0 = 0 ;
11273 PyObject * obj1 = 0 ;
11274 PyObject * obj2 = 0 ;
11275 char * kwnames[] = {
11276 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11277 };
11278
11279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11281 if (!SWIG_IsOK(res1)) {
11282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11283 }
11284 arg1 = reinterpret_cast< wxGrid * >(argp1);
11285 if (obj1) {
11286 ecode2 = SWIG_AsVal_int(obj1, &val2);
11287 if (!SWIG_IsOK(ecode2)) {
11288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11289 }
11290 arg2 = static_cast< int >(val2);
11291 }
11292 if (obj2) {
11293 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11294 if (!SWIG_IsOK(ecode3)) {
11295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11296 }
11297 arg3 = static_cast< bool >(val3);
11298 }
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (bool)(arg1)->AppendCols(arg2,arg3);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj = 0;
11316 wxGrid *arg1 = (wxGrid *) 0 ;
11317 int arg2 = (int) 0 ;
11318 int arg3 = (int) 1 ;
11319 bool arg4 = (bool) true ;
11320 bool result;
11321 void *argp1 = 0 ;
11322 int res1 = 0 ;
11323 int val2 ;
11324 int ecode2 = 0 ;
11325 int val3 ;
11326 int ecode3 = 0 ;
11327 bool val4 ;
11328 int ecode4 = 0 ;
11329 PyObject * obj0 = 0 ;
11330 PyObject * obj1 = 0 ;
11331 PyObject * obj2 = 0 ;
11332 PyObject * obj3 = 0 ;
11333 char * kwnames[] = {
11334 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11335 };
11336
11337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11339 if (!SWIG_IsOK(res1)) {
11340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11341 }
11342 arg1 = reinterpret_cast< wxGrid * >(argp1);
11343 if (obj1) {
11344 ecode2 = SWIG_AsVal_int(obj1, &val2);
11345 if (!SWIG_IsOK(ecode2)) {
11346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11347 }
11348 arg2 = static_cast< int >(val2);
11349 }
11350 if (obj2) {
11351 ecode3 = SWIG_AsVal_int(obj2, &val3);
11352 if (!SWIG_IsOK(ecode3)) {
11353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11354 }
11355 arg3 = static_cast< int >(val3);
11356 }
11357 if (obj3) {
11358 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11359 if (!SWIG_IsOK(ecode4)) {
11360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11361 }
11362 arg4 = static_cast< bool >(val4);
11363 }
11364 {
11365 PyThreadState* __tstate = wxPyBeginAllowThreads();
11366 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11367 wxPyEndAllowThreads(__tstate);
11368 if (PyErr_Occurred()) SWIG_fail;
11369 }
11370 {
11371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11372 }
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj = 0;
11381 wxGrid *arg1 = (wxGrid *) 0 ;
11382 wxDC *arg2 = 0 ;
11383 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11384 void *argp1 = 0 ;
11385 int res1 = 0 ;
11386 void *argp2 = 0 ;
11387 int res2 = 0 ;
11388 void *argp3 = 0 ;
11389 int res3 = 0 ;
11390 PyObject * obj0 = 0 ;
11391 PyObject * obj1 = 0 ;
11392 PyObject * obj2 = 0 ;
11393 char * kwnames[] = {
11394 (char *) "self",(char *) "dc",(char *) "attr", NULL
11395 };
11396
11397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11399 if (!SWIG_IsOK(res1)) {
11400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11401 }
11402 arg1 = reinterpret_cast< wxGrid * >(argp1);
11403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11404 if (!SWIG_IsOK(res2)) {
11405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11406 }
11407 if (!argp2) {
11408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11409 }
11410 arg2 = reinterpret_cast< wxDC * >(argp2);
11411 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11412 if (!SWIG_IsOK(res3)) {
11413 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11414 }
11415 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 resultobj = SWIG_Py_Void();
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxGrid *arg1 = (wxGrid *) 0 ;
11432 wxDC *arg2 = 0 ;
11433 wxString *arg3 = 0 ;
11434 wxRect *arg4 = 0 ;
11435 int arg5 = (int) wxLEFT ;
11436 int arg6 = (int) wxTOP ;
11437 int arg7 = (int) wxHORIZONTAL ;
11438 void *argp1 = 0 ;
11439 int res1 = 0 ;
11440 void *argp2 = 0 ;
11441 int res2 = 0 ;
11442 bool temp3 = false ;
11443 wxRect temp4 ;
11444 int val5 ;
11445 int ecode5 = 0 ;
11446 int val6 ;
11447 int ecode6 = 0 ;
11448 int val7 ;
11449 int ecode7 = 0 ;
11450 PyObject * obj0 = 0 ;
11451 PyObject * obj1 = 0 ;
11452 PyObject * obj2 = 0 ;
11453 PyObject * obj3 = 0 ;
11454 PyObject * obj4 = 0 ;
11455 PyObject * obj5 = 0 ;
11456 PyObject * obj6 = 0 ;
11457 char * kwnames[] = {
11458 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11459 };
11460
11461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11465 }
11466 arg1 = reinterpret_cast< wxGrid * >(argp1);
11467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11468 if (!SWIG_IsOK(res2)) {
11469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11470 }
11471 if (!argp2) {
11472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11473 }
11474 arg2 = reinterpret_cast< wxDC * >(argp2);
11475 {
11476 arg3 = wxString_in_helper(obj2);
11477 if (arg3 == NULL) SWIG_fail;
11478 temp3 = true;
11479 }
11480 {
11481 arg4 = &temp4;
11482 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11483 }
11484 if (obj4) {
11485 ecode5 = SWIG_AsVal_int(obj4, &val5);
11486 if (!SWIG_IsOK(ecode5)) {
11487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11488 }
11489 arg5 = static_cast< int >(val5);
11490 }
11491 if (obj5) {
11492 ecode6 = SWIG_AsVal_int(obj5, &val6);
11493 if (!SWIG_IsOK(ecode6)) {
11494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11495 }
11496 arg6 = static_cast< int >(val6);
11497 }
11498 if (obj6) {
11499 ecode7 = SWIG_AsVal_int(obj6, &val7);
11500 if (!SWIG_IsOK(ecode7)) {
11501 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11502 }
11503 arg7 = static_cast< int >(val7);
11504 }
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_Py_Void();
11512 {
11513 if (temp3)
11514 delete arg3;
11515 }
11516 return resultobj;
11517 fail:
11518 {
11519 if (temp3)
11520 delete arg3;
11521 }
11522 return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11527 PyObject *resultobj = 0;
11528 wxGrid *arg1 = (wxGrid *) 0 ;
11529 wxDC *arg2 = 0 ;
11530 wxArrayString *arg3 = 0 ;
11531 long *arg4 = (long *) 0 ;
11532 long *arg5 = (long *) 0 ;
11533 void *argp1 = 0 ;
11534 int res1 = 0 ;
11535 void *argp2 = 0 ;
11536 int res2 = 0 ;
11537 bool temp3 = false ;
11538 long temp4 ;
11539 int res4 = SWIG_TMPOBJ ;
11540 long temp5 ;
11541 int res5 = SWIG_TMPOBJ ;
11542 PyObject * obj0 = 0 ;
11543 PyObject * obj1 = 0 ;
11544 PyObject * obj2 = 0 ;
11545 char * kwnames[] = {
11546 (char *) "self",(char *) "dc",(char *) "lines", NULL
11547 };
11548
11549 arg4 = &temp4;
11550 arg5 = &temp5;
11551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11553 if (!SWIG_IsOK(res1)) {
11554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11555 }
11556 arg1 = reinterpret_cast< wxGrid * >(argp1);
11557 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11558 if (!SWIG_IsOK(res2)) {
11559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11560 }
11561 if (!argp2) {
11562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11563 }
11564 arg2 = reinterpret_cast< wxDC * >(argp2);
11565 {
11566 if (! PySequence_Check(obj2)) {
11567 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11568 SWIG_fail;
11569 }
11570 arg3 = new wxArrayString;
11571 temp3 = true;
11572 int i, len=PySequence_Length(obj2);
11573 for (i=0; i<len; i++) {
11574 PyObject* item = PySequence_GetItem(obj2, i);
11575 wxString* s = wxString_in_helper(item);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 arg3->Add(*s);
11578 delete s;
11579 Py_DECREF(item);
11580 }
11581 }
11582 {
11583 PyThreadState* __tstate = wxPyBeginAllowThreads();
11584 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11585 wxPyEndAllowThreads(__tstate);
11586 if (PyErr_Occurred()) SWIG_fail;
11587 }
11588 resultobj = SWIG_Py_Void();
11589 if (SWIG_IsTmpObj(res4)) {
11590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11591 } else {
11592 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11594 }
11595 if (SWIG_IsTmpObj(res5)) {
11596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11597 } else {
11598 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11600 }
11601 {
11602 if (temp3) delete arg3;
11603 }
11604 return resultobj;
11605 fail:
11606 {
11607 if (temp3) delete arg3;
11608 }
11609 return NULL;
11610 }
11611
11612
11613 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11614 PyObject *resultobj = 0;
11615 wxGrid *arg1 = (wxGrid *) 0 ;
11616 void *argp1 = 0 ;
11617 int res1 = 0 ;
11618 PyObject *swig_obj[1] ;
11619
11620 if (!args) SWIG_fail;
11621 swig_obj[0] = args;
11622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11623 if (!SWIG_IsOK(res1)) {
11624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11625 }
11626 arg1 = reinterpret_cast< wxGrid * >(argp1);
11627 {
11628 PyThreadState* __tstate = wxPyBeginAllowThreads();
11629 (arg1)->BeginBatch();
11630 wxPyEndAllowThreads(__tstate);
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 resultobj = SWIG_Py_Void();
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11641 PyObject *resultobj = 0;
11642 wxGrid *arg1 = (wxGrid *) 0 ;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 PyObject *swig_obj[1] ;
11646
11647 if (!args) SWIG_fail;
11648 swig_obj[0] = args;
11649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11652 }
11653 arg1 = reinterpret_cast< wxGrid * >(argp1);
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 (arg1)->EndBatch();
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 resultobj = SWIG_Py_Void();
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 wxGrid *arg1 = (wxGrid *) 0 ;
11670 int result;
11671 void *argp1 = 0 ;
11672 int res1 = 0 ;
11673 PyObject *swig_obj[1] ;
11674
11675 if (!args) SWIG_fail;
11676 swig_obj[0] = args;
11677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11680 }
11681 arg1 = reinterpret_cast< wxGrid * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (int)(arg1)->GetBatchCount();
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_From_int(static_cast< int >(result));
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 PyObject *resultobj = 0;
11697 wxGrid *arg1 = (wxGrid *) 0 ;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11707 }
11708 arg1 = reinterpret_cast< wxGrid * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->ForceRefresh();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxGrid *arg1 = (wxGrid *) 0 ;
11725 bool result;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11735 }
11736 arg1 = reinterpret_cast< wxGrid * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (bool)(arg1)->IsEditable();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 {
11744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11745 }
11746 return resultobj;
11747 fail:
11748 return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11753 PyObject *resultobj = 0;
11754 wxGrid *arg1 = (wxGrid *) 0 ;
11755 bool arg2 ;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 bool val2 ;
11759 int ecode2 = 0 ;
11760 PyObject * obj0 = 0 ;
11761 PyObject * obj1 = 0 ;
11762 char * kwnames[] = {
11763 (char *) "self",(char *) "edit", NULL
11764 };
11765
11766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11768 if (!SWIG_IsOK(res1)) {
11769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11770 }
11771 arg1 = reinterpret_cast< wxGrid * >(argp1);
11772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11773 if (!SWIG_IsOK(ecode2)) {
11774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11775 }
11776 arg2 = static_cast< bool >(val2);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 (arg1)->EnableEditing(arg2);
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_Py_Void();
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11791 PyObject *resultobj = 0;
11792 wxGrid *arg1 = (wxGrid *) 0 ;
11793 bool arg2 = (bool) true ;
11794 void *argp1 = 0 ;
11795 int res1 = 0 ;
11796 bool val2 ;
11797 int ecode2 = 0 ;
11798 PyObject * obj0 = 0 ;
11799 PyObject * obj1 = 0 ;
11800 char * kwnames[] = {
11801 (char *) "self",(char *) "enable", NULL
11802 };
11803
11804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11806 if (!SWIG_IsOK(res1)) {
11807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11808 }
11809 arg1 = reinterpret_cast< wxGrid * >(argp1);
11810 if (obj1) {
11811 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11812 if (!SWIG_IsOK(ecode2)) {
11813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11814 }
11815 arg2 = static_cast< bool >(val2);
11816 }
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 (arg1)->EnableCellEditControl(arg2);
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 resultobj = SWIG_Py_Void();
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxGrid *arg1 = (wxGrid *) 0 ;
11833 void *argp1 = 0 ;
11834 int res1 = 0 ;
11835 PyObject *swig_obj[1] ;
11836
11837 if (!args) SWIG_fail;
11838 swig_obj[0] = args;
11839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11840 if (!SWIG_IsOK(res1)) {
11841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11842 }
11843 arg1 = reinterpret_cast< wxGrid * >(argp1);
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 (arg1)->DisableCellEditControl();
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 resultobj = SWIG_Py_Void();
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11858 PyObject *resultobj = 0;
11859 wxGrid *arg1 = (wxGrid *) 0 ;
11860 bool result;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 PyObject *swig_obj[1] ;
11864
11865 if (!args) SWIG_fail;
11866 swig_obj[0] = args;
11867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11868 if (!SWIG_IsOK(res1)) {
11869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11870 }
11871 arg1 = reinterpret_cast< wxGrid * >(argp1);
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11888 PyObject *resultobj = 0;
11889 wxGrid *arg1 = (wxGrid *) 0 ;
11890 bool result;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 PyObject *swig_obj[1] ;
11894
11895 if (!args) SWIG_fail;
11896 swig_obj[0] = args;
11897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11898 if (!SWIG_IsOK(res1)) {
11899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11900 }
11901 arg1 = reinterpret_cast< wxGrid * >(argp1);
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11910 }
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11918 PyObject *resultobj = 0;
11919 wxGrid *arg1 = (wxGrid *) 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 PyObject *swig_obj[1] ;
11924
11925 if (!args) SWIG_fail;
11926 swig_obj[0] = args;
11927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11928 if (!SWIG_IsOK(res1)) {
11929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11930 }
11931 arg1 = reinterpret_cast< wxGrid * >(argp1);
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11935 wxPyEndAllowThreads(__tstate);
11936 if (PyErr_Occurred()) SWIG_fail;
11937 }
11938 {
11939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11940 }
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11948 PyObject *resultobj = 0;
11949 wxGrid *arg1 = (wxGrid *) 0 ;
11950 bool result;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 PyObject *swig_obj[1] ;
11954
11955 if (!args) SWIG_fail;
11956 swig_obj[0] = args;
11957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11960 }
11961 arg1 = reinterpret_cast< wxGrid * >(argp1);
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 {
11969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11970 }
11971 return resultobj;
11972 fail:
11973 return NULL;
11974 }
11975
11976
11977 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11978 PyObject *resultobj = 0;
11979 wxGrid *arg1 = (wxGrid *) 0 ;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 PyObject *swig_obj[1] ;
11983
11984 if (!args) SWIG_fail;
11985 swig_obj[0] = args;
11986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11989 }
11990 arg1 = reinterpret_cast< wxGrid * >(argp1);
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 (arg1)->ShowCellEditControl();
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 resultobj = SWIG_Py_Void();
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 PyObject *resultobj = 0;
12006 wxGrid *arg1 = (wxGrid *) 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 PyObject *swig_obj[1] ;
12010
12011 if (!args) SWIG_fail;
12012 swig_obj[0] = args;
12013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12016 }
12017 arg1 = reinterpret_cast< wxGrid * >(argp1);
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 (arg1)->HideCellEditControl();
12021 wxPyEndAllowThreads(__tstate);
12022 if (PyErr_Occurred()) SWIG_fail;
12023 }
12024 resultobj = SWIG_Py_Void();
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 PyObject *resultobj = 0;
12033 wxGrid *arg1 = (wxGrid *) 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 PyObject *swig_obj[1] ;
12037
12038 if (!args) SWIG_fail;
12039 swig_obj[0] = args;
12040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12041 if (!SWIG_IsOK(res1)) {
12042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12043 }
12044 arg1 = reinterpret_cast< wxGrid * >(argp1);
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 (arg1)->SaveEditControlValue();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 resultobj = SWIG_Py_Void();
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj = 0;
12060 wxGrid *arg1 = (wxGrid *) 0 ;
12061 int arg2 ;
12062 int arg3 ;
12063 wxGridCellCoords result;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 int val2 ;
12067 int ecode2 = 0 ;
12068 int val3 ;
12069 int ecode3 = 0 ;
12070 PyObject * obj0 = 0 ;
12071 PyObject * obj1 = 0 ;
12072 PyObject * obj2 = 0 ;
12073 char * kwnames[] = {
12074 (char *) "self",(char *) "x",(char *) "y", NULL
12075 };
12076
12077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12081 }
12082 arg1 = reinterpret_cast< wxGrid * >(argp1);
12083 ecode2 = SWIG_AsVal_int(obj1, &val2);
12084 if (!SWIG_IsOK(ecode2)) {
12085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12086 }
12087 arg2 = static_cast< int >(val2);
12088 ecode3 = SWIG_AsVal_int(obj2, &val3);
12089 if (!SWIG_IsOK(ecode3)) {
12090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12091 }
12092 arg3 = static_cast< int >(val3);
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = wxGrid_XYToCell(arg1,arg2,arg3);
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj = 0;
12108 wxGrid *arg1 = (wxGrid *) 0 ;
12109 int arg2 ;
12110 int result;
12111 void *argp1 = 0 ;
12112 int res1 = 0 ;
12113 int val2 ;
12114 int ecode2 = 0 ;
12115 PyObject * obj0 = 0 ;
12116 PyObject * obj1 = 0 ;
12117 char * kwnames[] = {
12118 (char *) "self",(char *) "y", NULL
12119 };
12120
12121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12123 if (!SWIG_IsOK(res1)) {
12124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12125 }
12126 arg1 = reinterpret_cast< wxGrid * >(argp1);
12127 ecode2 = SWIG_AsVal_int(obj1, &val2);
12128 if (!SWIG_IsOK(ecode2)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12130 }
12131 arg2 = static_cast< int >(val2);
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = (int)(arg1)->YToRow(arg2);
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 resultobj = SWIG_From_int(static_cast< int >(result));
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12146 PyObject *resultobj = 0;
12147 wxGrid *arg1 = (wxGrid *) 0 ;
12148 int arg2 ;
12149 int result;
12150 void *argp1 = 0 ;
12151 int res1 = 0 ;
12152 int val2 ;
12153 int ecode2 = 0 ;
12154 PyObject * obj0 = 0 ;
12155 PyObject * obj1 = 0 ;
12156 char * kwnames[] = {
12157 (char *) "self",(char *) "x", NULL
12158 };
12159
12160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) SWIG_fail;
12161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12162 if (!SWIG_IsOK(res1)) {
12163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12164 }
12165 arg1 = reinterpret_cast< wxGrid * >(argp1);
12166 ecode2 = SWIG_AsVal_int(obj1, &val2);
12167 if (!SWIG_IsOK(ecode2)) {
12168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12169 }
12170 arg2 = static_cast< int >(val2);
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (int)(arg1)->XToCol(arg2);
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_From_int(static_cast< int >(result));
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12185 PyObject *resultobj = 0;
12186 wxGrid *arg1 = (wxGrid *) 0 ;
12187 int arg2 ;
12188 int result;
12189 void *argp1 = 0 ;
12190 int res1 = 0 ;
12191 int val2 ;
12192 int ecode2 = 0 ;
12193 PyObject * obj0 = 0 ;
12194 PyObject * obj1 = 0 ;
12195 char * kwnames[] = {
12196 (char *) "self",(char *) "y", NULL
12197 };
12198
12199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12201 if (!SWIG_IsOK(res1)) {
12202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12203 }
12204 arg1 = reinterpret_cast< wxGrid * >(argp1);
12205 ecode2 = SWIG_AsVal_int(obj1, &val2);
12206 if (!SWIG_IsOK(ecode2)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12208 }
12209 arg2 = static_cast< int >(val2);
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (int)(arg1)->YToEdgeOfRow(arg2);
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = SWIG_From_int(static_cast< int >(result));
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj = 0;
12225 wxGrid *arg1 = (wxGrid *) 0 ;
12226 int arg2 ;
12227 int result;
12228 void *argp1 = 0 ;
12229 int res1 = 0 ;
12230 int val2 ;
12231 int ecode2 = 0 ;
12232 PyObject * obj0 = 0 ;
12233 PyObject * obj1 = 0 ;
12234 char * kwnames[] = {
12235 (char *) "self",(char *) "x", NULL
12236 };
12237
12238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12240 if (!SWIG_IsOK(res1)) {
12241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12242 }
12243 arg1 = reinterpret_cast< wxGrid * >(argp1);
12244 ecode2 = SWIG_AsVal_int(obj1, &val2);
12245 if (!SWIG_IsOK(ecode2)) {
12246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12247 }
12248 arg2 = static_cast< int >(val2);
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (int)(arg1)->XToEdgeOfCol(arg2);
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 resultobj = SWIG_From_int(static_cast< int >(result));
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 wxGrid *arg1 = (wxGrid *) 0 ;
12265 int arg2 ;
12266 int arg3 ;
12267 wxRect result;
12268 void *argp1 = 0 ;
12269 int res1 = 0 ;
12270 int val2 ;
12271 int ecode2 = 0 ;
12272 int val3 ;
12273 int ecode3 = 0 ;
12274 PyObject * obj0 = 0 ;
12275 PyObject * obj1 = 0 ;
12276 PyObject * obj2 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "self",(char *) "row",(char *) "col", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12283 if (!SWIG_IsOK(res1)) {
12284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12285 }
12286 arg1 = reinterpret_cast< wxGrid * >(argp1);
12287 ecode2 = SWIG_AsVal_int(obj1, &val2);
12288 if (!SWIG_IsOK(ecode2)) {
12289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12290 }
12291 arg2 = static_cast< int >(val2);
12292 ecode3 = SWIG_AsVal_int(obj2, &val3);
12293 if (!SWIG_IsOK(ecode3)) {
12294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12295 }
12296 arg3 = static_cast< int >(val3);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 result = (arg1)->CellToRect(arg2,arg3);
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 PyObject *resultobj = 0;
12312 wxGrid *arg1 = (wxGrid *) 0 ;
12313 int result;
12314 void *argp1 = 0 ;
12315 int res1 = 0 ;
12316 PyObject *swig_obj[1] ;
12317
12318 if (!args) SWIG_fail;
12319 swig_obj[0] = args;
12320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12321 if (!SWIG_IsOK(res1)) {
12322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12323 }
12324 arg1 = reinterpret_cast< wxGrid * >(argp1);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (int)(arg1)->GetGridCursorRow();
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_From_int(static_cast< int >(result));
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12339 PyObject *resultobj = 0;
12340 wxGrid *arg1 = (wxGrid *) 0 ;
12341 int result;
12342 void *argp1 = 0 ;
12343 int res1 = 0 ;
12344 PyObject *swig_obj[1] ;
12345
12346 if (!args) SWIG_fail;
12347 swig_obj[0] = args;
12348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12349 if (!SWIG_IsOK(res1)) {
12350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12351 }
12352 arg1 = reinterpret_cast< wxGrid * >(argp1);
12353 {
12354 PyThreadState* __tstate = wxPyBeginAllowThreads();
12355 result = (int)(arg1)->GetGridCursorCol();
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 resultobj = SWIG_From_int(static_cast< int >(result));
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj = 0;
12368 wxGrid *arg1 = (wxGrid *) 0 ;
12369 int arg2 ;
12370 int arg3 ;
12371 bool arg4 = (bool) true ;
12372 bool result;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 int val2 ;
12376 int ecode2 = 0 ;
12377 int val3 ;
12378 int ecode3 = 0 ;
12379 bool val4 ;
12380 int ecode4 = 0 ;
12381 PyObject * obj0 = 0 ;
12382 PyObject * obj1 = 0 ;
12383 PyObject * obj2 = 0 ;
12384 PyObject * obj3 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12393 }
12394 arg1 = reinterpret_cast< wxGrid * >(argp1);
12395 ecode2 = SWIG_AsVal_int(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12398 }
12399 arg2 = static_cast< int >(val2);
12400 ecode3 = SWIG_AsVal_int(obj2, &val3);
12401 if (!SWIG_IsOK(ecode3)) {
12402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12403 }
12404 arg3 = static_cast< int >(val3);
12405 if (obj3) {
12406 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12407 if (!SWIG_IsOK(ecode4)) {
12408 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12409 }
12410 arg4 = static_cast< bool >(val4);
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 {
12419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj = 0;
12429 wxGrid *arg1 = (wxGrid *) 0 ;
12430 int arg2 ;
12431 int arg3 ;
12432 void *argp1 = 0 ;
12433 int res1 = 0 ;
12434 int val2 ;
12435 int ecode2 = 0 ;
12436 int val3 ;
12437 int ecode3 = 0 ;
12438 PyObject * obj0 = 0 ;
12439 PyObject * obj1 = 0 ;
12440 PyObject * obj2 = 0 ;
12441 char * kwnames[] = {
12442 (char *) "self",(char *) "row",(char *) "col", NULL
12443 };
12444
12445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12447 if (!SWIG_IsOK(res1)) {
12448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12449 }
12450 arg1 = reinterpret_cast< wxGrid * >(argp1);
12451 ecode2 = SWIG_AsVal_int(obj1, &val2);
12452 if (!SWIG_IsOK(ecode2)) {
12453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12454 }
12455 arg2 = static_cast< int >(val2);
12456 ecode3 = SWIG_AsVal_int(obj2, &val3);
12457 if (!SWIG_IsOK(ecode3)) {
12458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12459 }
12460 arg3 = static_cast< int >(val3);
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 (arg1)->MakeCellVisible(arg2,arg3);
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = SWIG_Py_Void();
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj = 0;
12476 wxGrid *arg1 = (wxGrid *) 0 ;
12477 int arg2 ;
12478 int arg3 ;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 int val2 ;
12482 int ecode2 = 0 ;
12483 int val3 ;
12484 int ecode3 = 0 ;
12485 PyObject * obj0 = 0 ;
12486 PyObject * obj1 = 0 ;
12487 PyObject * obj2 = 0 ;
12488 char * kwnames[] = {
12489 (char *) "self",(char *) "row",(char *) "col", NULL
12490 };
12491
12492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12494 if (!SWIG_IsOK(res1)) {
12495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12496 }
12497 arg1 = reinterpret_cast< wxGrid * >(argp1);
12498 ecode2 = SWIG_AsVal_int(obj1, &val2);
12499 if (!SWIG_IsOK(ecode2)) {
12500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12501 }
12502 arg2 = static_cast< int >(val2);
12503 ecode3 = SWIG_AsVal_int(obj2, &val3);
12504 if (!SWIG_IsOK(ecode3)) {
12505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12506 }
12507 arg3 = static_cast< int >(val3);
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 (arg1)->SetGridCursor(arg2,arg3);
12511 wxPyEndAllowThreads(__tstate);
12512 if (PyErr_Occurred()) SWIG_fail;
12513 }
12514 resultobj = SWIG_Py_Void();
12515 return resultobj;
12516 fail:
12517 return NULL;
12518 }
12519
12520
12521 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12522 PyObject *resultobj = 0;
12523 wxGrid *arg1 = (wxGrid *) 0 ;
12524 bool arg2 ;
12525 bool result;
12526 void *argp1 = 0 ;
12527 int res1 = 0 ;
12528 bool val2 ;
12529 int ecode2 = 0 ;
12530 PyObject * obj0 = 0 ;
12531 PyObject * obj1 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "self",(char *) "expandSelection", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12540 }
12541 arg1 = reinterpret_cast< wxGrid * >(argp1);
12542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12543 if (!SWIG_IsOK(ecode2)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12545 }
12546 arg2 = static_cast< bool >(val2);
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (bool)(arg1)->MoveCursorUp(arg2);
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 {
12554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxGrid *arg1 = (wxGrid *) 0 ;
12565 bool arg2 ;
12566 bool result;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 bool val2 ;
12570 int ecode2 = 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 char * kwnames[] = {
12574 (char *) "self",(char *) "expandSelection", NULL
12575 };
12576
12577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12581 }
12582 arg1 = reinterpret_cast< wxGrid * >(argp1);
12583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12586 }
12587 arg2 = static_cast< bool >(val2);
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 result = (bool)(arg1)->MoveCursorDown(arg2);
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj = 0;
12605 wxGrid *arg1 = (wxGrid *) 0 ;
12606 bool arg2 ;
12607 bool result;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 bool val2 ;
12611 int ecode2 = 0 ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "self",(char *) "expandSelection", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12620 if (!SWIG_IsOK(res1)) {
12621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12622 }
12623 arg1 = reinterpret_cast< wxGrid * >(argp1);
12624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12625 if (!SWIG_IsOK(ecode2)) {
12626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12627 }
12628 arg2 = static_cast< bool >(val2);
12629 {
12630 PyThreadState* __tstate = wxPyBeginAllowThreads();
12631 result = (bool)(arg1)->MoveCursorLeft(arg2);
12632 wxPyEndAllowThreads(__tstate);
12633 if (PyErr_Occurred()) SWIG_fail;
12634 }
12635 {
12636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12637 }
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxGrid *arg1 = (wxGrid *) 0 ;
12647 bool arg2 ;
12648 bool result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 bool val2 ;
12652 int ecode2 = 0 ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 char * kwnames[] = {
12656 (char *) "self",(char *) "expandSelection", NULL
12657 };
12658
12659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12661 if (!SWIG_IsOK(res1)) {
12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12663 }
12664 arg1 = reinterpret_cast< wxGrid * >(argp1);
12665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12666 if (!SWIG_IsOK(ecode2)) {
12667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12668 }
12669 arg2 = static_cast< bool >(val2);
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (bool)(arg1)->MoveCursorRight(arg2);
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 {
12677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686 PyObject *resultobj = 0;
12687 wxGrid *arg1 = (wxGrid *) 0 ;
12688 bool result;
12689 void *argp1 = 0 ;
12690 int res1 = 0 ;
12691 PyObject *swig_obj[1] ;
12692
12693 if (!args) SWIG_fail;
12694 swig_obj[0] = args;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12698 }
12699 arg1 = reinterpret_cast< wxGrid * >(argp1);
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (bool)(arg1)->MovePageDown();
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 {
12707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12708 }
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12716 PyObject *resultobj = 0;
12717 wxGrid *arg1 = (wxGrid *) 0 ;
12718 bool result;
12719 void *argp1 = 0 ;
12720 int res1 = 0 ;
12721 PyObject *swig_obj[1] ;
12722
12723 if (!args) SWIG_fail;
12724 swig_obj[0] = args;
12725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12728 }
12729 arg1 = reinterpret_cast< wxGrid * >(argp1);
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (bool)(arg1)->MovePageUp();
12733 wxPyEndAllowThreads(__tstate);
12734 if (PyErr_Occurred()) SWIG_fail;
12735 }
12736 {
12737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12738 }
12739 return resultobj;
12740 fail:
12741 return NULL;
12742 }
12743
12744
12745 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12746 PyObject *resultobj = 0;
12747 wxGrid *arg1 = (wxGrid *) 0 ;
12748 bool arg2 ;
12749 bool result;
12750 void *argp1 = 0 ;
12751 int res1 = 0 ;
12752 bool val2 ;
12753 int ecode2 = 0 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 char * kwnames[] = {
12757 (char *) "self",(char *) "expandSelection", NULL
12758 };
12759
12760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12764 }
12765 arg1 = reinterpret_cast< wxGrid * >(argp1);
12766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12767 if (!SWIG_IsOK(ecode2)) {
12768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12769 }
12770 arg2 = static_cast< bool >(val2);
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 {
12778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12779 }
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12787 PyObject *resultobj = 0;
12788 wxGrid *arg1 = (wxGrid *) 0 ;
12789 bool arg2 ;
12790 bool result;
12791 void *argp1 = 0 ;
12792 int res1 = 0 ;
12793 bool val2 ;
12794 int ecode2 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 PyObject * obj1 = 0 ;
12797 char * kwnames[] = {
12798 (char *) "self",(char *) "expandSelection", NULL
12799 };
12800
12801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12805 }
12806 arg1 = reinterpret_cast< wxGrid * >(argp1);
12807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12808 if (!SWIG_IsOK(ecode2)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12810 }
12811 arg2 = static_cast< bool >(val2);
12812 {
12813 PyThreadState* __tstate = wxPyBeginAllowThreads();
12814 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 {
12819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12820 }
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj = 0;
12829 wxGrid *arg1 = (wxGrid *) 0 ;
12830 bool arg2 ;
12831 bool result;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 bool val2 ;
12835 int ecode2 = 0 ;
12836 PyObject * obj0 = 0 ;
12837 PyObject * obj1 = 0 ;
12838 char * kwnames[] = {
12839 (char *) "self",(char *) "expandSelection", NULL
12840 };
12841
12842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12844 if (!SWIG_IsOK(res1)) {
12845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12846 }
12847 arg1 = reinterpret_cast< wxGrid * >(argp1);
12848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12849 if (!SWIG_IsOK(ecode2)) {
12850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12851 }
12852 arg2 = static_cast< bool >(val2);
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 {
12860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12861 }
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj = 0;
12870 wxGrid *arg1 = (wxGrid *) 0 ;
12871 bool arg2 ;
12872 bool result;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 bool val2 ;
12876 int ecode2 = 0 ;
12877 PyObject * obj0 = 0 ;
12878 PyObject * obj1 = 0 ;
12879 char * kwnames[] = {
12880 (char *) "self",(char *) "expandSelection", NULL
12881 };
12882
12883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12885 if (!SWIG_IsOK(res1)) {
12886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12887 }
12888 arg1 = reinterpret_cast< wxGrid * >(argp1);
12889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12890 if (!SWIG_IsOK(ecode2)) {
12891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12892 }
12893 arg2 = static_cast< bool >(val2);
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 {
12901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12902 }
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 PyObject *resultobj = 0;
12911 wxGrid *arg1 = (wxGrid *) 0 ;
12912 int result;
12913 void *argp1 = 0 ;
12914 int res1 = 0 ;
12915 PyObject *swig_obj[1] ;
12916
12917 if (!args) SWIG_fail;
12918 swig_obj[0] = args;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12922 }
12923 arg1 = reinterpret_cast< wxGrid * >(argp1);
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = (int)(arg1)->GetDefaultRowLabelSize();
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 resultobj = SWIG_From_int(static_cast< int >(result));
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxGrid *arg1 = (wxGrid *) 0 ;
12940 int result;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject *swig_obj[1] ;
12944
12945 if (!args) SWIG_fail;
12946 swig_obj[0] = args;
12947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12950 }
12951 arg1 = reinterpret_cast< wxGrid * >(argp1);
12952 {
12953 PyThreadState* __tstate = wxPyBeginAllowThreads();
12954 result = (int)(arg1)->GetRowLabelSize();
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 resultobj = SWIG_From_int(static_cast< int >(result));
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 PyObject *resultobj = 0;
12967 wxGrid *arg1 = (wxGrid *) 0 ;
12968 int result;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 PyObject *swig_obj[1] ;
12972
12973 if (!args) SWIG_fail;
12974 swig_obj[0] = args;
12975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12976 if (!SWIG_IsOK(res1)) {
12977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12978 }
12979 arg1 = reinterpret_cast< wxGrid * >(argp1);
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 result = (int)(arg1)->GetDefaultColLabelSize();
12983 wxPyEndAllowThreads(__tstate);
12984 if (PyErr_Occurred()) SWIG_fail;
12985 }
12986 resultobj = SWIG_From_int(static_cast< int >(result));
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12994 PyObject *resultobj = 0;
12995 wxGrid *arg1 = (wxGrid *) 0 ;
12996 int result;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 PyObject *swig_obj[1] ;
13000
13001 if (!args) SWIG_fail;
13002 swig_obj[0] = args;
13003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13004 if (!SWIG_IsOK(res1)) {
13005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13006 }
13007 arg1 = reinterpret_cast< wxGrid * >(argp1);
13008 {
13009 PyThreadState* __tstate = wxPyBeginAllowThreads();
13010 result = (int)(arg1)->GetColLabelSize();
13011 wxPyEndAllowThreads(__tstate);
13012 if (PyErr_Occurred()) SWIG_fail;
13013 }
13014 resultobj = SWIG_From_int(static_cast< int >(result));
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 PyObject *resultobj = 0;
13023 wxGrid *arg1 = (wxGrid *) 0 ;
13024 wxColour result;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 PyObject *swig_obj[1] ;
13028
13029 if (!args) SWIG_fail;
13030 swig_obj[0] = args;
13031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13032 if (!SWIG_IsOK(res1)) {
13033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13034 }
13035 arg1 = reinterpret_cast< wxGrid * >(argp1);
13036 {
13037 PyThreadState* __tstate = wxPyBeginAllowThreads();
13038 result = (arg1)->GetLabelBackgroundColour();
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13043 return resultobj;
13044 fail:
13045 return NULL;
13046 }
13047
13048
13049 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13050 PyObject *resultobj = 0;
13051 wxGrid *arg1 = (wxGrid *) 0 ;
13052 wxColour result;
13053 void *argp1 = 0 ;
13054 int res1 = 0 ;
13055 PyObject *swig_obj[1] ;
13056
13057 if (!args) SWIG_fail;
13058 swig_obj[0] = args;
13059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13060 if (!SWIG_IsOK(res1)) {
13061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13062 }
13063 arg1 = reinterpret_cast< wxGrid * >(argp1);
13064 {
13065 PyThreadState* __tstate = wxPyBeginAllowThreads();
13066 result = (arg1)->GetLabelTextColour();
13067 wxPyEndAllowThreads(__tstate);
13068 if (PyErr_Occurred()) SWIG_fail;
13069 }
13070 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13071 return resultobj;
13072 fail:
13073 return NULL;
13074 }
13075
13076
13077 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13078 PyObject *resultobj = 0;
13079 wxGrid *arg1 = (wxGrid *) 0 ;
13080 wxFont result;
13081 void *argp1 = 0 ;
13082 int res1 = 0 ;
13083 PyObject *swig_obj[1] ;
13084
13085 if (!args) SWIG_fail;
13086 swig_obj[0] = args;
13087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13088 if (!SWIG_IsOK(res1)) {
13089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13090 }
13091 arg1 = reinterpret_cast< wxGrid * >(argp1);
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = (arg1)->GetLabelFont();
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13106 PyObject *resultobj = 0;
13107 wxGrid *arg1 = (wxGrid *) 0 ;
13108 int *arg2 = (int *) 0 ;
13109 int *arg3 = (int *) 0 ;
13110 void *argp1 = 0 ;
13111 int res1 = 0 ;
13112 int temp2 ;
13113 int res2 = SWIG_TMPOBJ ;
13114 int temp3 ;
13115 int res3 = SWIG_TMPOBJ ;
13116 PyObject *swig_obj[1] ;
13117
13118 arg2 = &temp2;
13119 arg3 = &temp3;
13120 if (!args) SWIG_fail;
13121 swig_obj[0] = args;
13122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13123 if (!SWIG_IsOK(res1)) {
13124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13125 }
13126 arg1 = reinterpret_cast< wxGrid * >(argp1);
13127 {
13128 PyThreadState* __tstate = wxPyBeginAllowThreads();
13129 (arg1)->GetRowLabelAlignment(arg2,arg3);
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 resultobj = SWIG_Py_Void();
13134 if (SWIG_IsTmpObj(res2)) {
13135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13136 } else {
13137 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13139 }
13140 if (SWIG_IsTmpObj(res3)) {
13141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13142 } else {
13143 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13145 }
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13153 PyObject *resultobj = 0;
13154 wxGrid *arg1 = (wxGrid *) 0 ;
13155 int *arg2 = (int *) 0 ;
13156 int *arg3 = (int *) 0 ;
13157 void *argp1 = 0 ;
13158 int res1 = 0 ;
13159 int temp2 ;
13160 int res2 = SWIG_TMPOBJ ;
13161 int temp3 ;
13162 int res3 = SWIG_TMPOBJ ;
13163 PyObject *swig_obj[1] ;
13164
13165 arg2 = &temp2;
13166 arg3 = &temp3;
13167 if (!args) SWIG_fail;
13168 swig_obj[0] = args;
13169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13170 if (!SWIG_IsOK(res1)) {
13171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13172 }
13173 arg1 = reinterpret_cast< wxGrid * >(argp1);
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 (arg1)->GetColLabelAlignment(arg2,arg3);
13177 wxPyEndAllowThreads(__tstate);
13178 if (PyErr_Occurred()) SWIG_fail;
13179 }
13180 resultobj = SWIG_Py_Void();
13181 if (SWIG_IsTmpObj(res2)) {
13182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13183 } else {
13184 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13186 }
13187 if (SWIG_IsTmpObj(res3)) {
13188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13189 } else {
13190 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13192 }
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13200 PyObject *resultobj = 0;
13201 wxGrid *arg1 = (wxGrid *) 0 ;
13202 int result;
13203 void *argp1 = 0 ;
13204 int res1 = 0 ;
13205 PyObject *swig_obj[1] ;
13206
13207 if (!args) SWIG_fail;
13208 swig_obj[0] = args;
13209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13210 if (!SWIG_IsOK(res1)) {
13211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13212 }
13213 arg1 = reinterpret_cast< wxGrid * >(argp1);
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 result = (int)(arg1)->GetColLabelTextOrientation();
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 resultobj = SWIG_From_int(static_cast< int >(result));
13221 return resultobj;
13222 fail:
13223 return NULL;
13224 }
13225
13226
13227 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj = 0;
13229 wxGrid *arg1 = (wxGrid *) 0 ;
13230 int arg2 ;
13231 wxString result;
13232 void *argp1 = 0 ;
13233 int res1 = 0 ;
13234 int val2 ;
13235 int ecode2 = 0 ;
13236 PyObject * obj0 = 0 ;
13237 PyObject * obj1 = 0 ;
13238 char * kwnames[] = {
13239 (char *) "self",(char *) "row", NULL
13240 };
13241
13242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13244 if (!SWIG_IsOK(res1)) {
13245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13246 }
13247 arg1 = reinterpret_cast< wxGrid * >(argp1);
13248 ecode2 = SWIG_AsVal_int(obj1, &val2);
13249 if (!SWIG_IsOK(ecode2)) {
13250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13251 }
13252 arg2 = static_cast< int >(val2);
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 result = (arg1)->GetRowLabelValue(arg2);
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 {
13260 #if wxUSE_UNICODE
13261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13262 #else
13263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13264 #endif
13265 }
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj = 0;
13274 wxGrid *arg1 = (wxGrid *) 0 ;
13275 int arg2 ;
13276 wxString result;
13277 void *argp1 = 0 ;
13278 int res1 = 0 ;
13279 int val2 ;
13280 int ecode2 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 char * kwnames[] = {
13284 (char *) "self",(char *) "col", NULL
13285 };
13286
13287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13289 if (!SWIG_IsOK(res1)) {
13290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13291 }
13292 arg1 = reinterpret_cast< wxGrid * >(argp1);
13293 ecode2 = SWIG_AsVal_int(obj1, &val2);
13294 if (!SWIG_IsOK(ecode2)) {
13295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13296 }
13297 arg2 = static_cast< int >(val2);
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = (arg1)->GetColLabelValue(arg2);
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 {
13305 #if wxUSE_UNICODE
13306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13307 #else
13308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13309 #endif
13310 }
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13318 PyObject *resultobj = 0;
13319 wxGrid *arg1 = (wxGrid *) 0 ;
13320 wxColour result;
13321 void *argp1 = 0 ;
13322 int res1 = 0 ;
13323 PyObject *swig_obj[1] ;
13324
13325 if (!args) SWIG_fail;
13326 swig_obj[0] = args;
13327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13330 }
13331 arg1 = reinterpret_cast< wxGrid * >(argp1);
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (arg1)->GetGridLineColour();
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13346 PyObject *resultobj = 0;
13347 wxGrid *arg1 = (wxGrid *) 0 ;
13348 wxColour result;
13349 void *argp1 = 0 ;
13350 int res1 = 0 ;
13351 PyObject *swig_obj[1] ;
13352
13353 if (!args) SWIG_fail;
13354 swig_obj[0] = args;
13355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13356 if (!SWIG_IsOK(res1)) {
13357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13358 }
13359 arg1 = reinterpret_cast< wxGrid * >(argp1);
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 result = (arg1)->GetCellHighlightColour();
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13374 PyObject *resultobj = 0;
13375 wxGrid *arg1 = (wxGrid *) 0 ;
13376 int result;
13377 void *argp1 = 0 ;
13378 int res1 = 0 ;
13379 PyObject *swig_obj[1] ;
13380
13381 if (!args) SWIG_fail;
13382 swig_obj[0] = args;
13383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13384 if (!SWIG_IsOK(res1)) {
13385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13386 }
13387 arg1 = reinterpret_cast< wxGrid * >(argp1);
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 result = (int)(arg1)->GetCellHighlightPenWidth();
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 resultobj = SWIG_From_int(static_cast< int >(result));
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13402 PyObject *resultobj = 0;
13403 wxGrid *arg1 = (wxGrid *) 0 ;
13404 int result;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 PyObject *swig_obj[1] ;
13408
13409 if (!args) SWIG_fail;
13410 swig_obj[0] = args;
13411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13412 if (!SWIG_IsOK(res1)) {
13413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13414 }
13415 arg1 = reinterpret_cast< wxGrid * >(argp1);
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 result = (int)(arg1)->GetCellHighlightROPenWidth();
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 resultobj = SWIG_From_int(static_cast< int >(result));
13423 return resultobj;
13424 fail:
13425 return NULL;
13426 }
13427
13428
13429 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13430 PyObject *resultobj = 0;
13431 wxGrid *arg1 = (wxGrid *) 0 ;
13432 int arg2 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 int val2 ;
13436 int ecode2 = 0 ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 char * kwnames[] = {
13440 (char *) "self",(char *) "width", NULL
13441 };
13442
13443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13445 if (!SWIG_IsOK(res1)) {
13446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13447 }
13448 arg1 = reinterpret_cast< wxGrid * >(argp1);
13449 ecode2 = SWIG_AsVal_int(obj1, &val2);
13450 if (!SWIG_IsOK(ecode2)) {
13451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13452 }
13453 arg2 = static_cast< int >(val2);
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 (arg1)->SetRowLabelSize(arg2);
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_Py_Void();
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj = 0;
13469 wxGrid *arg1 = (wxGrid *) 0 ;
13470 int arg2 ;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 int val2 ;
13474 int ecode2 = 0 ;
13475 PyObject * obj0 = 0 ;
13476 PyObject * obj1 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "self",(char *) "height", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13483 if (!SWIG_IsOK(res1)) {
13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13485 }
13486 arg1 = reinterpret_cast< wxGrid * >(argp1);
13487 ecode2 = SWIG_AsVal_int(obj1, &val2);
13488 if (!SWIG_IsOK(ecode2)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13490 }
13491 arg2 = static_cast< int >(val2);
13492 {
13493 PyThreadState* __tstate = wxPyBeginAllowThreads();
13494 (arg1)->SetColLabelSize(arg2);
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 resultobj = SWIG_Py_Void();
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 wxGrid *arg1 = (wxGrid *) 0 ;
13508 wxColour *arg2 = 0 ;
13509 void *argp1 = 0 ;
13510 int res1 = 0 ;
13511 wxColour temp2 ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "self",(char *)"arg2", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13520 if (!SWIG_IsOK(res1)) {
13521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13522 }
13523 arg1 = reinterpret_cast< wxGrid * >(argp1);
13524 {
13525 arg2 = &temp2;
13526 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13527 }
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 resultobj = SWIG_Py_Void();
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxGrid *arg1 = (wxGrid *) 0 ;
13544 wxColour *arg2 = 0 ;
13545 void *argp1 = 0 ;
13546 int res1 = 0 ;
13547 wxColour temp2 ;
13548 PyObject * obj0 = 0 ;
13549 PyObject * obj1 = 0 ;
13550 char * kwnames[] = {
13551 (char *) "self",(char *)"arg2", NULL
13552 };
13553
13554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13556 if (!SWIG_IsOK(res1)) {
13557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13558 }
13559 arg1 = reinterpret_cast< wxGrid * >(argp1);
13560 {
13561 arg2 = &temp2;
13562 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 resultobj = SWIG_Py_Void();
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 wxGrid *arg1 = (wxGrid *) 0 ;
13580 wxFont *arg2 = 0 ;
13581 void *argp1 = 0 ;
13582 int res1 = 0 ;
13583 void *argp2 = 0 ;
13584 int res2 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 char * kwnames[] = {
13588 (char *) "self",(char *)"arg2", NULL
13589 };
13590
13591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13593 if (!SWIG_IsOK(res1)) {
13594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13595 }
13596 arg1 = reinterpret_cast< wxGrid * >(argp1);
13597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13598 if (!SWIG_IsOK(res2)) {
13599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13600 }
13601 if (!argp2) {
13602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13603 }
13604 arg2 = reinterpret_cast< wxFont * >(argp2);
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 (arg1)->SetLabelFont((wxFont const &)*arg2);
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_Py_Void();
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj = 0;
13620 wxGrid *arg1 = (wxGrid *) 0 ;
13621 int arg2 ;
13622 int arg3 ;
13623 void *argp1 = 0 ;
13624 int res1 = 0 ;
13625 int val2 ;
13626 int ecode2 = 0 ;
13627 int val3 ;
13628 int ecode3 = 0 ;
13629 PyObject * obj0 = 0 ;
13630 PyObject * obj1 = 0 ;
13631 PyObject * obj2 = 0 ;
13632 char * kwnames[] = {
13633 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13634 };
13635
13636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13638 if (!SWIG_IsOK(res1)) {
13639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13640 }
13641 arg1 = reinterpret_cast< wxGrid * >(argp1);
13642 ecode2 = SWIG_AsVal_int(obj1, &val2);
13643 if (!SWIG_IsOK(ecode2)) {
13644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13645 }
13646 arg2 = static_cast< int >(val2);
13647 ecode3 = SWIG_AsVal_int(obj2, &val3);
13648 if (!SWIG_IsOK(ecode3)) {
13649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13650 }
13651 arg3 = static_cast< int >(val3);
13652 {
13653 PyThreadState* __tstate = wxPyBeginAllowThreads();
13654 (arg1)->SetRowLabelAlignment(arg2,arg3);
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 resultobj = SWIG_Py_Void();
13659 return resultobj;
13660 fail:
13661 return NULL;
13662 }
13663
13664
13665 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13666 PyObject *resultobj = 0;
13667 wxGrid *arg1 = (wxGrid *) 0 ;
13668 int arg2 ;
13669 int arg3 ;
13670 void *argp1 = 0 ;
13671 int res1 = 0 ;
13672 int val2 ;
13673 int ecode2 = 0 ;
13674 int val3 ;
13675 int ecode3 = 0 ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 char * kwnames[] = {
13680 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13681 };
13682
13683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13685 if (!SWIG_IsOK(res1)) {
13686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13687 }
13688 arg1 = reinterpret_cast< wxGrid * >(argp1);
13689 ecode2 = SWIG_AsVal_int(obj1, &val2);
13690 if (!SWIG_IsOK(ecode2)) {
13691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13692 }
13693 arg2 = static_cast< int >(val2);
13694 ecode3 = SWIG_AsVal_int(obj2, &val3);
13695 if (!SWIG_IsOK(ecode3)) {
13696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13697 }
13698 arg3 = static_cast< int >(val3);
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 (arg1)->SetColLabelAlignment(arg2,arg3);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 resultobj = SWIG_Py_Void();
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj = 0;
13714 wxGrid *arg1 = (wxGrid *) 0 ;
13715 int arg2 ;
13716 void *argp1 = 0 ;
13717 int res1 = 0 ;
13718 int val2 ;
13719 int ecode2 = 0 ;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 char * kwnames[] = {
13723 (char *) "self",(char *) "textOrientation", NULL
13724 };
13725
13726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13728 if (!SWIG_IsOK(res1)) {
13729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13730 }
13731 arg1 = reinterpret_cast< wxGrid * >(argp1);
13732 ecode2 = SWIG_AsVal_int(obj1, &val2);
13733 if (!SWIG_IsOK(ecode2)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13735 }
13736 arg2 = static_cast< int >(val2);
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->SetColLabelTextOrientation(arg2);
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 resultobj = SWIG_Py_Void();
13744 return resultobj;
13745 fail:
13746 return NULL;
13747 }
13748
13749
13750 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13751 PyObject *resultobj = 0;
13752 wxGrid *arg1 = (wxGrid *) 0 ;
13753 int arg2 ;
13754 wxString *arg3 = 0 ;
13755 void *argp1 = 0 ;
13756 int res1 = 0 ;
13757 int val2 ;
13758 int ecode2 = 0 ;
13759 bool temp3 = false ;
13760 PyObject * obj0 = 0 ;
13761 PyObject * obj1 = 0 ;
13762 PyObject * obj2 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "self",(char *) "row",(char *)"arg3", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13769 if (!SWIG_IsOK(res1)) {
13770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13771 }
13772 arg1 = reinterpret_cast< wxGrid * >(argp1);
13773 ecode2 = SWIG_AsVal_int(obj1, &val2);
13774 if (!SWIG_IsOK(ecode2)) {
13775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13776 }
13777 arg2 = static_cast< int >(val2);
13778 {
13779 arg3 = wxString_in_helper(obj2);
13780 if (arg3 == NULL) SWIG_fail;
13781 temp3 = true;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_Py_Void();
13790 {
13791 if (temp3)
13792 delete arg3;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp3)
13798 delete arg3;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxGrid *arg1 = (wxGrid *) 0 ;
13807 int arg2 ;
13808 wxString *arg3 = 0 ;
13809 void *argp1 = 0 ;
13810 int res1 = 0 ;
13811 int val2 ;
13812 int ecode2 = 0 ;
13813 bool temp3 = false ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 PyObject * obj2 = 0 ;
13817 char * kwnames[] = {
13818 (char *) "self",(char *) "col",(char *)"arg3", NULL
13819 };
13820
13821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13823 if (!SWIG_IsOK(res1)) {
13824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13825 }
13826 arg1 = reinterpret_cast< wxGrid * >(argp1);
13827 ecode2 = SWIG_AsVal_int(obj1, &val2);
13828 if (!SWIG_IsOK(ecode2)) {
13829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13830 }
13831 arg2 = static_cast< int >(val2);
13832 {
13833 arg3 = wxString_in_helper(obj2);
13834 if (arg3 == NULL) SWIG_fail;
13835 temp3 = true;
13836 }
13837 {
13838 PyThreadState* __tstate = wxPyBeginAllowThreads();
13839 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 resultobj = SWIG_Py_Void();
13844 {
13845 if (temp3)
13846 delete arg3;
13847 }
13848 return resultobj;
13849 fail:
13850 {
13851 if (temp3)
13852 delete arg3;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj = 0;
13860 wxGrid *arg1 = (wxGrid *) 0 ;
13861 wxColour *arg2 = 0 ;
13862 void *argp1 = 0 ;
13863 int res1 = 0 ;
13864 wxColour temp2 ;
13865 PyObject * obj0 = 0 ;
13866 PyObject * obj1 = 0 ;
13867 char * kwnames[] = {
13868 (char *) "self",(char *)"arg2", NULL
13869 };
13870
13871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13873 if (!SWIG_IsOK(res1)) {
13874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13875 }
13876 arg1 = reinterpret_cast< wxGrid * >(argp1);
13877 {
13878 arg2 = &temp2;
13879 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 resultobj = SWIG_Py_Void();
13888 return resultobj;
13889 fail:
13890 return NULL;
13891 }
13892
13893
13894 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13895 PyObject *resultobj = 0;
13896 wxGrid *arg1 = (wxGrid *) 0 ;
13897 wxColour *arg2 = 0 ;
13898 void *argp1 = 0 ;
13899 int res1 = 0 ;
13900 wxColour temp2 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "self",(char *)"arg2", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13909 if (!SWIG_IsOK(res1)) {
13910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13911 }
13912 arg1 = reinterpret_cast< wxGrid * >(argp1);
13913 {
13914 arg2 = &temp2;
13915 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13916 }
13917 {
13918 PyThreadState* __tstate = wxPyBeginAllowThreads();
13919 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13920 wxPyEndAllowThreads(__tstate);
13921 if (PyErr_Occurred()) SWIG_fail;
13922 }
13923 resultobj = SWIG_Py_Void();
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = 0;
13932 wxGrid *arg1 = (wxGrid *) 0 ;
13933 int arg2 ;
13934 void *argp1 = 0 ;
13935 int res1 = 0 ;
13936 int val2 ;
13937 int ecode2 = 0 ;
13938 PyObject * obj0 = 0 ;
13939 PyObject * obj1 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "self",(char *) "width", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13946 if (!SWIG_IsOK(res1)) {
13947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13948 }
13949 arg1 = reinterpret_cast< wxGrid * >(argp1);
13950 ecode2 = SWIG_AsVal_int(obj1, &val2);
13951 if (!SWIG_IsOK(ecode2)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13953 }
13954 arg2 = static_cast< int >(val2);
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 (arg1)->SetCellHighlightPenWidth(arg2);
13958 wxPyEndAllowThreads(__tstate);
13959 if (PyErr_Occurred()) SWIG_fail;
13960 }
13961 resultobj = SWIG_Py_Void();
13962 return resultobj;
13963 fail:
13964 return NULL;
13965 }
13966
13967
13968 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj = 0;
13970 wxGrid *arg1 = (wxGrid *) 0 ;
13971 int arg2 ;
13972 void *argp1 = 0 ;
13973 int res1 = 0 ;
13974 int val2 ;
13975 int ecode2 = 0 ;
13976 PyObject * obj0 = 0 ;
13977 PyObject * obj1 = 0 ;
13978 char * kwnames[] = {
13979 (char *) "self",(char *) "width", NULL
13980 };
13981
13982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13984 if (!SWIG_IsOK(res1)) {
13985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13986 }
13987 arg1 = reinterpret_cast< wxGrid * >(argp1);
13988 ecode2 = SWIG_AsVal_int(obj1, &val2);
13989 if (!SWIG_IsOK(ecode2)) {
13990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13991 }
13992 arg2 = static_cast< int >(val2);
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 (arg1)->SetCellHighlightROPenWidth(arg2);
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_Py_Void();
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj = 0;
14008 wxGrid *arg1 = (wxGrid *) 0 ;
14009 bool arg2 = (bool) true ;
14010 void *argp1 = 0 ;
14011 int res1 = 0 ;
14012 bool val2 ;
14013 int ecode2 = 0 ;
14014 PyObject * obj0 = 0 ;
14015 PyObject * obj1 = 0 ;
14016 char * kwnames[] = {
14017 (char *) "self",(char *) "enable", NULL
14018 };
14019
14020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14022 if (!SWIG_IsOK(res1)) {
14023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14024 }
14025 arg1 = reinterpret_cast< wxGrid * >(argp1);
14026 if (obj1) {
14027 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14028 if (!SWIG_IsOK(ecode2)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14030 }
14031 arg2 = static_cast< bool >(val2);
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 (arg1)->EnableDragRowSize(arg2);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_Py_Void();
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14047 PyObject *resultobj = 0;
14048 wxGrid *arg1 = (wxGrid *) 0 ;
14049 void *argp1 = 0 ;
14050 int res1 = 0 ;
14051 PyObject *swig_obj[1] ;
14052
14053 if (!args) SWIG_fail;
14054 swig_obj[0] = args;
14055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14058 }
14059 arg1 = reinterpret_cast< wxGrid * >(argp1);
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 (arg1)->DisableDragRowSize();
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 resultobj = SWIG_Py_Void();
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14074 PyObject *resultobj = 0;
14075 wxGrid *arg1 = (wxGrid *) 0 ;
14076 bool result;
14077 void *argp1 = 0 ;
14078 int res1 = 0 ;
14079 PyObject *swig_obj[1] ;
14080
14081 if (!args) SWIG_fail;
14082 swig_obj[0] = args;
14083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14084 if (!SWIG_IsOK(res1)) {
14085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14086 }
14087 arg1 = reinterpret_cast< wxGrid * >(argp1);
14088 {
14089 PyThreadState* __tstate = wxPyBeginAllowThreads();
14090 result = (bool)(arg1)->CanDragRowSize();
14091 wxPyEndAllowThreads(__tstate);
14092 if (PyErr_Occurred()) SWIG_fail;
14093 }
14094 {
14095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14096 }
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14104 PyObject *resultobj = 0;
14105 wxGrid *arg1 = (wxGrid *) 0 ;
14106 bool arg2 = (bool) true ;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 bool val2 ;
14110 int ecode2 = 0 ;
14111 PyObject * obj0 = 0 ;
14112 PyObject * obj1 = 0 ;
14113 char * kwnames[] = {
14114 (char *) "self",(char *) "enable", NULL
14115 };
14116
14117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14119 if (!SWIG_IsOK(res1)) {
14120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14121 }
14122 arg1 = reinterpret_cast< wxGrid * >(argp1);
14123 if (obj1) {
14124 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14125 if (!SWIG_IsOK(ecode2)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14127 }
14128 arg2 = static_cast< bool >(val2);
14129 }
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 (arg1)->EnableDragColSize(arg2);
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 resultobj = SWIG_Py_Void();
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 PyObject *resultobj = 0;
14145 wxGrid *arg1 = (wxGrid *) 0 ;
14146 void *argp1 = 0 ;
14147 int res1 = 0 ;
14148 PyObject *swig_obj[1] ;
14149
14150 if (!args) SWIG_fail;
14151 swig_obj[0] = args;
14152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14153 if (!SWIG_IsOK(res1)) {
14154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14155 }
14156 arg1 = reinterpret_cast< wxGrid * >(argp1);
14157 {
14158 PyThreadState* __tstate = wxPyBeginAllowThreads();
14159 (arg1)->DisableDragColSize();
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 resultobj = SWIG_Py_Void();
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14171 PyObject *resultobj = 0;
14172 wxGrid *arg1 = (wxGrid *) 0 ;
14173 bool result;
14174 void *argp1 = 0 ;
14175 int res1 = 0 ;
14176 PyObject *swig_obj[1] ;
14177
14178 if (!args) SWIG_fail;
14179 swig_obj[0] = args;
14180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14183 }
14184 arg1 = reinterpret_cast< wxGrid * >(argp1);
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (bool)(arg1)->CanDragColSize();
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 {
14192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14193 }
14194 return resultobj;
14195 fail:
14196 return NULL;
14197 }
14198
14199
14200 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj = 0;
14202 wxGrid *arg1 = (wxGrid *) 0 ;
14203 bool arg2 = (bool) true ;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 bool val2 ;
14207 int ecode2 = 0 ;
14208 PyObject * obj0 = 0 ;
14209 PyObject * obj1 = 0 ;
14210 char * kwnames[] = {
14211 (char *) "self",(char *) "enable", NULL
14212 };
14213
14214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14216 if (!SWIG_IsOK(res1)) {
14217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14218 }
14219 arg1 = reinterpret_cast< wxGrid * >(argp1);
14220 if (obj1) {
14221 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14222 if (!SWIG_IsOK(ecode2)) {
14223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14224 }
14225 arg2 = static_cast< bool >(val2);
14226 }
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 (arg1)->EnableDragGridSize(arg2);
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 resultobj = SWIG_Py_Void();
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *resultobj = 0;
14242 wxGrid *arg1 = (wxGrid *) 0 ;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 PyObject *swig_obj[1] ;
14246
14247 if (!args) SWIG_fail;
14248 swig_obj[0] = args;
14249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14250 if (!SWIG_IsOK(res1)) {
14251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14252 }
14253 arg1 = reinterpret_cast< wxGrid * >(argp1);
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 (arg1)->DisableDragGridSize();
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_Py_Void();
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14268 PyObject *resultobj = 0;
14269 wxGrid *arg1 = (wxGrid *) 0 ;
14270 bool result;
14271 void *argp1 = 0 ;
14272 int res1 = 0 ;
14273 PyObject *swig_obj[1] ;
14274
14275 if (!args) SWIG_fail;
14276 swig_obj[0] = args;
14277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14278 if (!SWIG_IsOK(res1)) {
14279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14280 }
14281 arg1 = reinterpret_cast< wxGrid * >(argp1);
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (bool)(arg1)->CanDragGridSize();
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 {
14289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14290 }
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj = 0;
14299 wxGrid *arg1 = (wxGrid *) 0 ;
14300 bool arg2 = (bool) true ;
14301 void *argp1 = 0 ;
14302 int res1 = 0 ;
14303 bool val2 ;
14304 int ecode2 = 0 ;
14305 PyObject * obj0 = 0 ;
14306 PyObject * obj1 = 0 ;
14307 char * kwnames[] = {
14308 (char *) "self",(char *) "enable", NULL
14309 };
14310
14311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14313 if (!SWIG_IsOK(res1)) {
14314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14315 }
14316 arg1 = reinterpret_cast< wxGrid * >(argp1);
14317 if (obj1) {
14318 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14319 if (!SWIG_IsOK(ecode2)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14321 }
14322 arg2 = static_cast< bool >(val2);
14323 }
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 (arg1)->EnableDragCell(arg2);
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 resultobj = SWIG_Py_Void();
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14338 PyObject *resultobj = 0;
14339 wxGrid *arg1 = (wxGrid *) 0 ;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 PyObject *swig_obj[1] ;
14343
14344 if (!args) SWIG_fail;
14345 swig_obj[0] = args;
14346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14347 if (!SWIG_IsOK(res1)) {
14348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14349 }
14350 arg1 = reinterpret_cast< wxGrid * >(argp1);
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 (arg1)->DisableDragCell();
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 resultobj = SWIG_Py_Void();
14358 return resultobj;
14359 fail:
14360 return NULL;
14361 }
14362
14363
14364 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14365 PyObject *resultobj = 0;
14366 wxGrid *arg1 = (wxGrid *) 0 ;
14367 bool result;
14368 void *argp1 = 0 ;
14369 int res1 = 0 ;
14370 PyObject *swig_obj[1] ;
14371
14372 if (!args) SWIG_fail;
14373 swig_obj[0] = args;
14374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14375 if (!SWIG_IsOK(res1)) {
14376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14377 }
14378 arg1 = reinterpret_cast< wxGrid * >(argp1);
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (bool)(arg1)->CanDragCell();
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 {
14386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14387 }
14388 return resultobj;
14389 fail:
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxGrid *arg1 = (wxGrid *) 0 ;
14397 int arg2 ;
14398 int arg3 ;
14399 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 int val2 ;
14403 int ecode2 = 0 ;
14404 int val3 ;
14405 int ecode3 = 0 ;
14406 void *argp4 = 0 ;
14407 int res4 = 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 PyObject * obj2 = 0 ;
14411 PyObject * obj3 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14420 }
14421 arg1 = reinterpret_cast< wxGrid * >(argp1);
14422 ecode2 = SWIG_AsVal_int(obj1, &val2);
14423 if (!SWIG_IsOK(ecode2)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14425 }
14426 arg2 = static_cast< int >(val2);
14427 ecode3 = SWIG_AsVal_int(obj2, &val3);
14428 if (!SWIG_IsOK(ecode3)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14430 }
14431 arg3 = static_cast< int >(val3);
14432 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14433 if (!SWIG_IsOK(res4)) {
14434 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14435 }
14436 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 (arg1)->SetAttr(arg2,arg3,arg4);
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = SWIG_Py_Void();
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj = 0;
14452 wxGrid *arg1 = (wxGrid *) 0 ;
14453 int arg2 ;
14454 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14455 void *argp1 = 0 ;
14456 int res1 = 0 ;
14457 int val2 ;
14458 int ecode2 = 0 ;
14459 void *argp3 = 0 ;
14460 int res3 = 0 ;
14461 PyObject * obj0 = 0 ;
14462 PyObject * obj1 = 0 ;
14463 PyObject * obj2 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "self",(char *) "row",(char *) "attr", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14472 }
14473 arg1 = reinterpret_cast< wxGrid * >(argp1);
14474 ecode2 = SWIG_AsVal_int(obj1, &val2);
14475 if (!SWIG_IsOK(ecode2)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14477 }
14478 arg2 = static_cast< int >(val2);
14479 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14480 if (!SWIG_IsOK(res3)) {
14481 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14482 }
14483 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 (arg1)->SetRowAttr(arg2,arg3);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = SWIG_Py_Void();
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxGrid *arg1 = (wxGrid *) 0 ;
14500 int arg2 ;
14501 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14502 void *argp1 = 0 ;
14503 int res1 = 0 ;
14504 int val2 ;
14505 int ecode2 = 0 ;
14506 void *argp3 = 0 ;
14507 int res3 = 0 ;
14508 PyObject * obj0 = 0 ;
14509 PyObject * obj1 = 0 ;
14510 PyObject * obj2 = 0 ;
14511 char * kwnames[] = {
14512 (char *) "self",(char *) "col",(char *) "attr", NULL
14513 };
14514
14515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14517 if (!SWIG_IsOK(res1)) {
14518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14519 }
14520 arg1 = reinterpret_cast< wxGrid * >(argp1);
14521 ecode2 = SWIG_AsVal_int(obj1, &val2);
14522 if (!SWIG_IsOK(ecode2)) {
14523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14524 }
14525 arg2 = static_cast< int >(val2);
14526 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14527 if (!SWIG_IsOK(res3)) {
14528 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14529 }
14530 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14531 {
14532 PyThreadState* __tstate = wxPyBeginAllowThreads();
14533 (arg1)->SetColAttr(arg2,arg3);
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 resultobj = SWIG_Py_Void();
14538 return resultobj;
14539 fail:
14540 return NULL;
14541 }
14542
14543
14544 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14545 PyObject *resultobj = 0;
14546 wxGrid *arg1 = (wxGrid *) 0 ;
14547 int arg2 ;
14548 int arg3 ;
14549 wxGridCellAttr *result = 0 ;
14550 void *argp1 = 0 ;
14551 int res1 = 0 ;
14552 int val2 ;
14553 int ecode2 = 0 ;
14554 int val3 ;
14555 int ecode3 = 0 ;
14556 PyObject * obj0 = 0 ;
14557 PyObject * obj1 = 0 ;
14558 PyObject * obj2 = 0 ;
14559 char * kwnames[] = {
14560 (char *) "self",(char *) "row",(char *) "col", NULL
14561 };
14562
14563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14565 if (!SWIG_IsOK(res1)) {
14566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14567 }
14568 arg1 = reinterpret_cast< wxGrid * >(argp1);
14569 ecode2 = SWIG_AsVal_int(obj1, &val2);
14570 if (!SWIG_IsOK(ecode2)) {
14571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14572 }
14573 arg2 = static_cast< int >(val2);
14574 ecode3 = SWIG_AsVal_int(obj2, &val3);
14575 if (!SWIG_IsOK(ecode3)) {
14576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14577 }
14578 arg3 = static_cast< int >(val3);
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 {
14586 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14587 }
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj = 0;
14596 wxGrid *arg1 = (wxGrid *) 0 ;
14597 int arg2 ;
14598 void *argp1 = 0 ;
14599 int res1 = 0 ;
14600 int val2 ;
14601 int ecode2 = 0 ;
14602 PyObject * obj0 = 0 ;
14603 PyObject * obj1 = 0 ;
14604 char * kwnames[] = {
14605 (char *) "self",(char *) "col", NULL
14606 };
14607
14608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14610 if (!SWIG_IsOK(res1)) {
14611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14612 }
14613 arg1 = reinterpret_cast< wxGrid * >(argp1);
14614 ecode2 = SWIG_AsVal_int(obj1, &val2);
14615 if (!SWIG_IsOK(ecode2)) {
14616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14617 }
14618 arg2 = static_cast< int >(val2);
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 (arg1)->SetColFormatBool(arg2);
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 resultobj = SWIG_Py_Void();
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxGrid *arg1 = (wxGrid *) 0 ;
14635 int arg2 ;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 int val2 ;
14639 int ecode2 = 0 ;
14640 PyObject * obj0 = 0 ;
14641 PyObject * obj1 = 0 ;
14642 char * kwnames[] = {
14643 (char *) "self",(char *) "col", NULL
14644 };
14645
14646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14648 if (!SWIG_IsOK(res1)) {
14649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14650 }
14651 arg1 = reinterpret_cast< wxGrid * >(argp1);
14652 ecode2 = SWIG_AsVal_int(obj1, &val2);
14653 if (!SWIG_IsOK(ecode2)) {
14654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14655 }
14656 arg2 = static_cast< int >(val2);
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 (arg1)->SetColFormatNumber(arg2);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 resultobj = SWIG_Py_Void();
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 wxGrid *arg1 = (wxGrid *) 0 ;
14673 int arg2 ;
14674 int arg3 = (int) -1 ;
14675 int arg4 = (int) -1 ;
14676 void *argp1 = 0 ;
14677 int res1 = 0 ;
14678 int val2 ;
14679 int ecode2 = 0 ;
14680 int val3 ;
14681 int ecode3 = 0 ;
14682 int val4 ;
14683 int ecode4 = 0 ;
14684 PyObject * obj0 = 0 ;
14685 PyObject * obj1 = 0 ;
14686 PyObject * obj2 = 0 ;
14687 PyObject * obj3 = 0 ;
14688 char * kwnames[] = {
14689 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14690 };
14691
14692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14694 if (!SWIG_IsOK(res1)) {
14695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14696 }
14697 arg1 = reinterpret_cast< wxGrid * >(argp1);
14698 ecode2 = SWIG_AsVal_int(obj1, &val2);
14699 if (!SWIG_IsOK(ecode2)) {
14700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14701 }
14702 arg2 = static_cast< int >(val2);
14703 if (obj2) {
14704 ecode3 = SWIG_AsVal_int(obj2, &val3);
14705 if (!SWIG_IsOK(ecode3)) {
14706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14707 }
14708 arg3 = static_cast< int >(val3);
14709 }
14710 if (obj3) {
14711 ecode4 = SWIG_AsVal_int(obj3, &val4);
14712 if (!SWIG_IsOK(ecode4)) {
14713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14714 }
14715 arg4 = static_cast< int >(val4);
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 resultobj = SWIG_Py_Void();
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14731 PyObject *resultobj = 0;
14732 wxGrid *arg1 = (wxGrid *) 0 ;
14733 int arg2 ;
14734 wxString *arg3 = 0 ;
14735 void *argp1 = 0 ;
14736 int res1 = 0 ;
14737 int val2 ;
14738 int ecode2 = 0 ;
14739 bool temp3 = false ;
14740 PyObject * obj0 = 0 ;
14741 PyObject * obj1 = 0 ;
14742 PyObject * obj2 = 0 ;
14743 char * kwnames[] = {
14744 (char *) "self",(char *) "col",(char *) "typeName", NULL
14745 };
14746
14747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14749 if (!SWIG_IsOK(res1)) {
14750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14751 }
14752 arg1 = reinterpret_cast< wxGrid * >(argp1);
14753 ecode2 = SWIG_AsVal_int(obj1, &val2);
14754 if (!SWIG_IsOK(ecode2)) {
14755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14756 }
14757 arg2 = static_cast< int >(val2);
14758 {
14759 arg3 = wxString_in_helper(obj2);
14760 if (arg3 == NULL) SWIG_fail;
14761 temp3 = true;
14762 }
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 resultobj = SWIG_Py_Void();
14770 {
14771 if (temp3)
14772 delete arg3;
14773 }
14774 return resultobj;
14775 fail:
14776 {
14777 if (temp3)
14778 delete arg3;
14779 }
14780 return NULL;
14781 }
14782
14783
14784 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14785 PyObject *resultobj = 0;
14786 wxGrid *arg1 = (wxGrid *) 0 ;
14787 bool arg2 = (bool) true ;
14788 void *argp1 = 0 ;
14789 int res1 = 0 ;
14790 bool val2 ;
14791 int ecode2 = 0 ;
14792 PyObject * obj0 = 0 ;
14793 PyObject * obj1 = 0 ;
14794 char * kwnames[] = {
14795 (char *) "self",(char *) "enable", NULL
14796 };
14797
14798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14802 }
14803 arg1 = reinterpret_cast< wxGrid * >(argp1);
14804 if (obj1) {
14805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14806 if (!SWIG_IsOK(ecode2)) {
14807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14808 }
14809 arg2 = static_cast< bool >(val2);
14810 }
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 (arg1)->EnableGridLines(arg2);
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 resultobj = SWIG_Py_Void();
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14825 PyObject *resultobj = 0;
14826 wxGrid *arg1 = (wxGrid *) 0 ;
14827 bool result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 PyObject *swig_obj[1] ;
14831
14832 if (!args) SWIG_fail;
14833 swig_obj[0] = args;
14834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14837 }
14838 arg1 = reinterpret_cast< wxGrid * >(argp1);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (bool)(arg1)->GridLinesEnabled();
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14855 PyObject *resultobj = 0;
14856 wxGrid *arg1 = (wxGrid *) 0 ;
14857 int result;
14858 void *argp1 = 0 ;
14859 int res1 = 0 ;
14860 PyObject *swig_obj[1] ;
14861
14862 if (!args) SWIG_fail;
14863 swig_obj[0] = args;
14864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14865 if (!SWIG_IsOK(res1)) {
14866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14867 }
14868 arg1 = reinterpret_cast< wxGrid * >(argp1);
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 result = (int)(arg1)->GetDefaultRowSize();
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 resultobj = SWIG_From_int(static_cast< int >(result));
14876 return resultobj;
14877 fail:
14878 return NULL;
14879 }
14880
14881
14882 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14883 PyObject *resultobj = 0;
14884 wxGrid *arg1 = (wxGrid *) 0 ;
14885 int arg2 ;
14886 int result;
14887 void *argp1 = 0 ;
14888 int res1 = 0 ;
14889 int val2 ;
14890 int ecode2 = 0 ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "self",(char *) "row", NULL
14895 };
14896
14897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14899 if (!SWIG_IsOK(res1)) {
14900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14901 }
14902 arg1 = reinterpret_cast< wxGrid * >(argp1);
14903 ecode2 = SWIG_AsVal_int(obj1, &val2);
14904 if (!SWIG_IsOK(ecode2)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14906 }
14907 arg2 = static_cast< int >(val2);
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (int)(arg1)->GetRowSize(arg2);
14911 wxPyEndAllowThreads(__tstate);
14912 if (PyErr_Occurred()) SWIG_fail;
14913 }
14914 resultobj = SWIG_From_int(static_cast< int >(result));
14915 return resultobj;
14916 fail:
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14922 PyObject *resultobj = 0;
14923 wxGrid *arg1 = (wxGrid *) 0 ;
14924 int result;
14925 void *argp1 = 0 ;
14926 int res1 = 0 ;
14927 PyObject *swig_obj[1] ;
14928
14929 if (!args) SWIG_fail;
14930 swig_obj[0] = args;
14931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14932 if (!SWIG_IsOK(res1)) {
14933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14934 }
14935 arg1 = reinterpret_cast< wxGrid * >(argp1);
14936 {
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (int)(arg1)->GetDefaultColSize();
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 resultobj = SWIG_From_int(static_cast< int >(result));
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = 0;
14951 wxGrid *arg1 = (wxGrid *) 0 ;
14952 int arg2 ;
14953 int result;
14954 void *argp1 = 0 ;
14955 int res1 = 0 ;
14956 int val2 ;
14957 int ecode2 = 0 ;
14958 PyObject * obj0 = 0 ;
14959 PyObject * obj1 = 0 ;
14960 char * kwnames[] = {
14961 (char *) "self",(char *) "col", NULL
14962 };
14963
14964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14968 }
14969 arg1 = reinterpret_cast< wxGrid * >(argp1);
14970 ecode2 = SWIG_AsVal_int(obj1, &val2);
14971 if (!SWIG_IsOK(ecode2)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14973 }
14974 arg2 = static_cast< int >(val2);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (int)(arg1)->GetColSize(arg2);
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_From_int(static_cast< int >(result));
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14989 PyObject *resultobj = 0;
14990 wxGrid *arg1 = (wxGrid *) 0 ;
14991 wxColour result;
14992 void *argp1 = 0 ;
14993 int res1 = 0 ;
14994 PyObject *swig_obj[1] ;
14995
14996 if (!args) SWIG_fail;
14997 swig_obj[0] = args;
14998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14999 if (!SWIG_IsOK(res1)) {
15000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15001 }
15002 arg1 = reinterpret_cast< wxGrid * >(argp1);
15003 {
15004 PyThreadState* __tstate = wxPyBeginAllowThreads();
15005 result = (arg1)->GetDefaultCellBackgroundColour();
15006 wxPyEndAllowThreads(__tstate);
15007 if (PyErr_Occurred()) SWIG_fail;
15008 }
15009 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15010 return resultobj;
15011 fail:
15012 return NULL;
15013 }
15014
15015
15016 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15017 PyObject *resultobj = 0;
15018 wxGrid *arg1 = (wxGrid *) 0 ;
15019 int arg2 ;
15020 int arg3 ;
15021 wxColour result;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 int val2 ;
15025 int ecode2 = 0 ;
15026 int val3 ;
15027 int ecode3 = 0 ;
15028 PyObject * obj0 = 0 ;
15029 PyObject * obj1 = 0 ;
15030 PyObject * obj2 = 0 ;
15031 char * kwnames[] = {
15032 (char *) "self",(char *) "row",(char *) "col", NULL
15033 };
15034
15035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15037 if (!SWIG_IsOK(res1)) {
15038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15039 }
15040 arg1 = reinterpret_cast< wxGrid * >(argp1);
15041 ecode2 = SWIG_AsVal_int(obj1, &val2);
15042 if (!SWIG_IsOK(ecode2)) {
15043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15044 }
15045 arg2 = static_cast< int >(val2);
15046 ecode3 = SWIG_AsVal_int(obj2, &val3);
15047 if (!SWIG_IsOK(ecode3)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15049 }
15050 arg3 = static_cast< int >(val3);
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15065 PyObject *resultobj = 0;
15066 wxGrid *arg1 = (wxGrid *) 0 ;
15067 wxColour result;
15068 void *argp1 = 0 ;
15069 int res1 = 0 ;
15070 PyObject *swig_obj[1] ;
15071
15072 if (!args) SWIG_fail;
15073 swig_obj[0] = args;
15074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15075 if (!SWIG_IsOK(res1)) {
15076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15077 }
15078 arg1 = reinterpret_cast< wxGrid * >(argp1);
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (arg1)->GetDefaultCellTextColour();
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj = 0;
15094 wxGrid *arg1 = (wxGrid *) 0 ;
15095 int arg2 ;
15096 int arg3 ;
15097 wxColour result;
15098 void *argp1 = 0 ;
15099 int res1 = 0 ;
15100 int val2 ;
15101 int ecode2 = 0 ;
15102 int val3 ;
15103 int ecode3 = 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 PyObject * obj2 = 0 ;
15107 char * kwnames[] = {
15108 (char *) "self",(char *) "row",(char *) "col", NULL
15109 };
15110
15111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15113 if (!SWIG_IsOK(res1)) {
15114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15115 }
15116 arg1 = reinterpret_cast< wxGrid * >(argp1);
15117 ecode2 = SWIG_AsVal_int(obj1, &val2);
15118 if (!SWIG_IsOK(ecode2)) {
15119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15120 }
15121 arg2 = static_cast< int >(val2);
15122 ecode3 = SWIG_AsVal_int(obj2, &val3);
15123 if (!SWIG_IsOK(ecode3)) {
15124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15125 }
15126 arg3 = static_cast< int >(val3);
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 result = (arg1)->GetCellTextColour(arg2,arg3);
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15141 PyObject *resultobj = 0;
15142 wxGrid *arg1 = (wxGrid *) 0 ;
15143 wxFont result;
15144 void *argp1 = 0 ;
15145 int res1 = 0 ;
15146 PyObject *swig_obj[1] ;
15147
15148 if (!args) SWIG_fail;
15149 swig_obj[0] = args;
15150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15153 }
15154 arg1 = reinterpret_cast< wxGrid * >(argp1);
15155 {
15156 PyThreadState* __tstate = wxPyBeginAllowThreads();
15157 result = (arg1)->GetDefaultCellFont();
15158 wxPyEndAllowThreads(__tstate);
15159 if (PyErr_Occurred()) SWIG_fail;
15160 }
15161 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj = 0;
15170 wxGrid *arg1 = (wxGrid *) 0 ;
15171 int arg2 ;
15172 int arg3 ;
15173 wxFont result;
15174 void *argp1 = 0 ;
15175 int res1 = 0 ;
15176 int val2 ;
15177 int ecode2 = 0 ;
15178 int val3 ;
15179 int ecode3 = 0 ;
15180 PyObject * obj0 = 0 ;
15181 PyObject * obj1 = 0 ;
15182 PyObject * obj2 = 0 ;
15183 char * kwnames[] = {
15184 (char *) "self",(char *) "row",(char *) "col", NULL
15185 };
15186
15187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15189 if (!SWIG_IsOK(res1)) {
15190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15191 }
15192 arg1 = reinterpret_cast< wxGrid * >(argp1);
15193 ecode2 = SWIG_AsVal_int(obj1, &val2);
15194 if (!SWIG_IsOK(ecode2)) {
15195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15196 }
15197 arg2 = static_cast< int >(val2);
15198 ecode3 = SWIG_AsVal_int(obj2, &val3);
15199 if (!SWIG_IsOK(ecode3)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15201 }
15202 arg3 = static_cast< int >(val3);
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 result = (arg1)->GetCellFont(arg2,arg3);
15206 wxPyEndAllowThreads(__tstate);
15207 if (PyErr_Occurred()) SWIG_fail;
15208 }
15209 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxGrid *arg1 = (wxGrid *) 0 ;
15219 int *arg2 = (int *) 0 ;
15220 int *arg3 = (int *) 0 ;
15221 void *argp1 = 0 ;
15222 int res1 = 0 ;
15223 int temp2 ;
15224 int res2 = SWIG_TMPOBJ ;
15225 int temp3 ;
15226 int res3 = SWIG_TMPOBJ ;
15227 PyObject *swig_obj[1] ;
15228
15229 arg2 = &temp2;
15230 arg3 = &temp3;
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15236 }
15237 arg1 = reinterpret_cast< wxGrid * >(argp1);
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_Py_Void();
15245 if (SWIG_IsTmpObj(res2)) {
15246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15247 } else {
15248 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15250 }
15251 if (SWIG_IsTmpObj(res3)) {
15252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15253 } else {
15254 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15256 }
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj = 0;
15265 wxGrid *arg1 = (wxGrid *) 0 ;
15266 int arg2 ;
15267 int arg3 ;
15268 int *arg4 = (int *) 0 ;
15269 int *arg5 = (int *) 0 ;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 int val2 ;
15273 int ecode2 = 0 ;
15274 int val3 ;
15275 int ecode3 = 0 ;
15276 int temp4 ;
15277 int res4 = SWIG_TMPOBJ ;
15278 int temp5 ;
15279 int res5 = SWIG_TMPOBJ ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 PyObject * obj2 = 0 ;
15283 char * kwnames[] = {
15284 (char *) "self",(char *) "row",(char *) "col", NULL
15285 };
15286
15287 arg4 = &temp4;
15288 arg5 = &temp5;
15289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15291 if (!SWIG_IsOK(res1)) {
15292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15293 }
15294 arg1 = reinterpret_cast< wxGrid * >(argp1);
15295 ecode2 = SWIG_AsVal_int(obj1, &val2);
15296 if (!SWIG_IsOK(ecode2)) {
15297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15298 }
15299 arg2 = static_cast< int >(val2);
15300 ecode3 = SWIG_AsVal_int(obj2, &val3);
15301 if (!SWIG_IsOK(ecode3)) {
15302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15303 }
15304 arg3 = static_cast< int >(val3);
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = SWIG_Py_Void();
15312 if (SWIG_IsTmpObj(res4)) {
15313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15314 } else {
15315 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15317 }
15318 if (SWIG_IsTmpObj(res5)) {
15319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15320 } else {
15321 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15323 }
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *resultobj = 0;
15332 wxGrid *arg1 = (wxGrid *) 0 ;
15333 bool result;
15334 void *argp1 = 0 ;
15335 int res1 = 0 ;
15336 PyObject *swig_obj[1] ;
15337
15338 if (!args) SWIG_fail;
15339 swig_obj[0] = args;
15340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15341 if (!SWIG_IsOK(res1)) {
15342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15343 }
15344 arg1 = reinterpret_cast< wxGrid * >(argp1);
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 result = (bool)(arg1)->GetDefaultCellOverflow();
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 {
15352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15353 }
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15361 PyObject *resultobj = 0;
15362 wxGrid *arg1 = (wxGrid *) 0 ;
15363 int arg2 ;
15364 int arg3 ;
15365 bool result;
15366 void *argp1 = 0 ;
15367 int res1 = 0 ;
15368 int val2 ;
15369 int ecode2 = 0 ;
15370 int val3 ;
15371 int ecode3 = 0 ;
15372 PyObject * obj0 = 0 ;
15373 PyObject * obj1 = 0 ;
15374 PyObject * obj2 = 0 ;
15375 char * kwnames[] = {
15376 (char *) "self",(char *) "row",(char *) "col", NULL
15377 };
15378
15379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15381 if (!SWIG_IsOK(res1)) {
15382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15383 }
15384 arg1 = reinterpret_cast< wxGrid * >(argp1);
15385 ecode2 = SWIG_AsVal_int(obj1, &val2);
15386 if (!SWIG_IsOK(ecode2)) {
15387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15388 }
15389 arg2 = static_cast< int >(val2);
15390 ecode3 = SWIG_AsVal_int(obj2, &val3);
15391 if (!SWIG_IsOK(ecode3)) {
15392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15393 }
15394 arg3 = static_cast< int >(val3);
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15398 wxPyEndAllowThreads(__tstate);
15399 if (PyErr_Occurred()) SWIG_fail;
15400 }
15401 {
15402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15403 }
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15411 PyObject *resultobj = 0;
15412 wxGrid *arg1 = (wxGrid *) 0 ;
15413 int arg2 ;
15414 int arg3 ;
15415 int *arg4 = (int *) 0 ;
15416 int *arg5 = (int *) 0 ;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 int val2 ;
15420 int ecode2 = 0 ;
15421 int val3 ;
15422 int ecode3 = 0 ;
15423 int temp4 ;
15424 int res4 = SWIG_TMPOBJ ;
15425 int temp5 ;
15426 int res5 = SWIG_TMPOBJ ;
15427 PyObject * obj0 = 0 ;
15428 PyObject * obj1 = 0 ;
15429 PyObject * obj2 = 0 ;
15430 char * kwnames[] = {
15431 (char *) "self",(char *) "row",(char *) "col", NULL
15432 };
15433
15434 arg4 = &temp4;
15435 arg5 = &temp5;
15436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15438 if (!SWIG_IsOK(res1)) {
15439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15440 }
15441 arg1 = reinterpret_cast< wxGrid * >(argp1);
15442 ecode2 = SWIG_AsVal_int(obj1, &val2);
15443 if (!SWIG_IsOK(ecode2)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15445 }
15446 arg2 = static_cast< int >(val2);
15447 ecode3 = SWIG_AsVal_int(obj2, &val3);
15448 if (!SWIG_IsOK(ecode3)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15450 }
15451 arg3 = static_cast< int >(val3);
15452 {
15453 PyThreadState* __tstate = wxPyBeginAllowThreads();
15454 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_Py_Void();
15459 if (SWIG_IsTmpObj(res4)) {
15460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15461 } else {
15462 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15464 }
15465 if (SWIG_IsTmpObj(res5)) {
15466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15467 } else {
15468 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15470 }
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15478 PyObject *resultobj = 0;
15479 wxGrid *arg1 = (wxGrid *) 0 ;
15480 int arg2 ;
15481 bool arg3 = (bool) false ;
15482 void *argp1 = 0 ;
15483 int res1 = 0 ;
15484 int val2 ;
15485 int ecode2 = 0 ;
15486 bool val3 ;
15487 int ecode3 = 0 ;
15488 PyObject * obj0 = 0 ;
15489 PyObject * obj1 = 0 ;
15490 PyObject * obj2 = 0 ;
15491 char * kwnames[] = {
15492 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15493 };
15494
15495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15497 if (!SWIG_IsOK(res1)) {
15498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15499 }
15500 arg1 = reinterpret_cast< wxGrid * >(argp1);
15501 ecode2 = SWIG_AsVal_int(obj1, &val2);
15502 if (!SWIG_IsOK(ecode2)) {
15503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15504 }
15505 arg2 = static_cast< int >(val2);
15506 if (obj2) {
15507 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15508 if (!SWIG_IsOK(ecode3)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15510 }
15511 arg3 = static_cast< bool >(val3);
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 (arg1)->SetDefaultRowSize(arg2,arg3);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_Py_Void();
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15527 PyObject *resultobj = 0;
15528 wxGrid *arg1 = (wxGrid *) 0 ;
15529 int arg2 ;
15530 int arg3 ;
15531 void *argp1 = 0 ;
15532 int res1 = 0 ;
15533 int val2 ;
15534 int ecode2 = 0 ;
15535 int val3 ;
15536 int ecode3 = 0 ;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 PyObject * obj2 = 0 ;
15540 char * kwnames[] = {
15541 (char *) "self",(char *) "row",(char *) "height", NULL
15542 };
15543
15544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15546 if (!SWIG_IsOK(res1)) {
15547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15548 }
15549 arg1 = reinterpret_cast< wxGrid * >(argp1);
15550 ecode2 = SWIG_AsVal_int(obj1, &val2);
15551 if (!SWIG_IsOK(ecode2)) {
15552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15553 }
15554 arg2 = static_cast< int >(val2);
15555 ecode3 = SWIG_AsVal_int(obj2, &val3);
15556 if (!SWIG_IsOK(ecode3)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15558 }
15559 arg3 = static_cast< int >(val3);
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 (arg1)->SetRowSize(arg2,arg3);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxGrid *arg1 = (wxGrid *) 0 ;
15576 int arg2 ;
15577 bool arg3 = (bool) false ;
15578 void *argp1 = 0 ;
15579 int res1 = 0 ;
15580 int val2 ;
15581 int ecode2 = 0 ;
15582 bool val3 ;
15583 int ecode3 = 0 ;
15584 PyObject * obj0 = 0 ;
15585 PyObject * obj1 = 0 ;
15586 PyObject * obj2 = 0 ;
15587 char * kwnames[] = {
15588 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15589 };
15590
15591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15593 if (!SWIG_IsOK(res1)) {
15594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15595 }
15596 arg1 = reinterpret_cast< wxGrid * >(argp1);
15597 ecode2 = SWIG_AsVal_int(obj1, &val2);
15598 if (!SWIG_IsOK(ecode2)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15600 }
15601 arg2 = static_cast< int >(val2);
15602 if (obj2) {
15603 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15604 if (!SWIG_IsOK(ecode3)) {
15605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15606 }
15607 arg3 = static_cast< bool >(val3);
15608 }
15609 {
15610 PyThreadState* __tstate = wxPyBeginAllowThreads();
15611 (arg1)->SetDefaultColSize(arg2,arg3);
15612 wxPyEndAllowThreads(__tstate);
15613 if (PyErr_Occurred()) SWIG_fail;
15614 }
15615 resultobj = SWIG_Py_Void();
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15623 PyObject *resultobj = 0;
15624 wxGrid *arg1 = (wxGrid *) 0 ;
15625 int arg2 ;
15626 int arg3 ;
15627 void *argp1 = 0 ;
15628 int res1 = 0 ;
15629 int val2 ;
15630 int ecode2 = 0 ;
15631 int val3 ;
15632 int ecode3 = 0 ;
15633 PyObject * obj0 = 0 ;
15634 PyObject * obj1 = 0 ;
15635 PyObject * obj2 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "self",(char *) "col",(char *) "width", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15642 if (!SWIG_IsOK(res1)) {
15643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15644 }
15645 arg1 = reinterpret_cast< wxGrid * >(argp1);
15646 ecode2 = SWIG_AsVal_int(obj1, &val2);
15647 if (!SWIG_IsOK(ecode2)) {
15648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15649 }
15650 arg2 = static_cast< int >(val2);
15651 ecode3 = SWIG_AsVal_int(obj2, &val3);
15652 if (!SWIG_IsOK(ecode3)) {
15653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15654 }
15655 arg3 = static_cast< int >(val3);
15656 {
15657 PyThreadState* __tstate = wxPyBeginAllowThreads();
15658 (arg1)->SetColSize(arg2,arg3);
15659 wxPyEndAllowThreads(__tstate);
15660 if (PyErr_Occurred()) SWIG_fail;
15661 }
15662 resultobj = SWIG_Py_Void();
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj = 0;
15671 wxGrid *arg1 = (wxGrid *) 0 ;
15672 int arg2 ;
15673 bool arg3 = (bool) true ;
15674 void *argp1 = 0 ;
15675 int res1 = 0 ;
15676 int val2 ;
15677 int ecode2 = 0 ;
15678 bool val3 ;
15679 int ecode3 = 0 ;
15680 PyObject * obj0 = 0 ;
15681 PyObject * obj1 = 0 ;
15682 PyObject * obj2 = 0 ;
15683 char * kwnames[] = {
15684 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15685 };
15686
15687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15689 if (!SWIG_IsOK(res1)) {
15690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15691 }
15692 arg1 = reinterpret_cast< wxGrid * >(argp1);
15693 ecode2 = SWIG_AsVal_int(obj1, &val2);
15694 if (!SWIG_IsOK(ecode2)) {
15695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15696 }
15697 arg2 = static_cast< int >(val2);
15698 if (obj2) {
15699 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15700 if (!SWIG_IsOK(ecode3)) {
15701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15702 }
15703 arg3 = static_cast< bool >(val3);
15704 }
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 (arg1)->AutoSizeColumn(arg2,arg3);
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_Py_Void();
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj = 0;
15720 wxGrid *arg1 = (wxGrid *) 0 ;
15721 int arg2 ;
15722 bool arg3 = (bool) true ;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 int val2 ;
15726 int ecode2 = 0 ;
15727 bool val3 ;
15728 int ecode3 = 0 ;
15729 PyObject * obj0 = 0 ;
15730 PyObject * obj1 = 0 ;
15731 PyObject * obj2 = 0 ;
15732 char * kwnames[] = {
15733 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15734 };
15735
15736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15738 if (!SWIG_IsOK(res1)) {
15739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15740 }
15741 arg1 = reinterpret_cast< wxGrid * >(argp1);
15742 ecode2 = SWIG_AsVal_int(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15745 }
15746 arg2 = static_cast< int >(val2);
15747 if (obj2) {
15748 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15749 if (!SWIG_IsOK(ecode3)) {
15750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15751 }
15752 arg3 = static_cast< bool >(val3);
15753 }
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 (arg1)->AutoSizeRow(arg2,arg3);
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 resultobj = SWIG_Py_Void();
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = 0;
15769 wxGrid *arg1 = (wxGrid *) 0 ;
15770 bool arg2 = (bool) true ;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 bool val2 ;
15774 int ecode2 = 0 ;
15775 PyObject * obj0 = 0 ;
15776 PyObject * obj1 = 0 ;
15777 char * kwnames[] = {
15778 (char *) "self",(char *) "setAsMin", NULL
15779 };
15780
15781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15783 if (!SWIG_IsOK(res1)) {
15784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15785 }
15786 arg1 = reinterpret_cast< wxGrid * >(argp1);
15787 if (obj1) {
15788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15791 }
15792 arg2 = static_cast< bool >(val2);
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 (arg1)->AutoSizeColumns(arg2);
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 resultobj = SWIG_Py_Void();
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj = 0;
15809 wxGrid *arg1 = (wxGrid *) 0 ;
15810 bool arg2 = (bool) true ;
15811 void *argp1 = 0 ;
15812 int res1 = 0 ;
15813 bool val2 ;
15814 int ecode2 = 0 ;
15815 PyObject * obj0 = 0 ;
15816 PyObject * obj1 = 0 ;
15817 char * kwnames[] = {
15818 (char *) "self",(char *) "setAsMin", NULL
15819 };
15820
15821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15823 if (!SWIG_IsOK(res1)) {
15824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15825 }
15826 arg1 = reinterpret_cast< wxGrid * >(argp1);
15827 if (obj1) {
15828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15829 if (!SWIG_IsOK(ecode2)) {
15830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15831 }
15832 arg2 = static_cast< bool >(val2);
15833 }
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 (arg1)->AutoSizeRows(arg2);
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 resultobj = SWIG_Py_Void();
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15848 PyObject *resultobj = 0;
15849 wxGrid *arg1 = (wxGrid *) 0 ;
15850 void *argp1 = 0 ;
15851 int res1 = 0 ;
15852 PyObject *swig_obj[1] ;
15853
15854 if (!args) SWIG_fail;
15855 swig_obj[0] = args;
15856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15857 if (!SWIG_IsOK(res1)) {
15858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15859 }
15860 arg1 = reinterpret_cast< wxGrid * >(argp1);
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 (arg1)->AutoSize();
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 resultobj = SWIG_Py_Void();
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = 0;
15876 wxGrid *arg1 = (wxGrid *) 0 ;
15877 int arg2 ;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 int val2 ;
15881 int ecode2 = 0 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char * kwnames[] = {
15885 (char *) "self",(char *) "row", NULL
15886 };
15887
15888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15890 if (!SWIG_IsOK(res1)) {
15891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15892 }
15893 arg1 = reinterpret_cast< wxGrid * >(argp1);
15894 ecode2 = SWIG_AsVal_int(obj1, &val2);
15895 if (!SWIG_IsOK(ecode2)) {
15896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15897 }
15898 arg2 = static_cast< int >(val2);
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 (arg1)->AutoSizeRowLabelSize(arg2);
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_Py_Void();
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxGrid *arg1 = (wxGrid *) 0 ;
15915 int arg2 ;
15916 void *argp1 = 0 ;
15917 int res1 = 0 ;
15918 int val2 ;
15919 int ecode2 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char * kwnames[] = {
15923 (char *) "self",(char *) "col", NULL
15924 };
15925
15926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15930 }
15931 arg1 = reinterpret_cast< wxGrid * >(argp1);
15932 ecode2 = SWIG_AsVal_int(obj1, &val2);
15933 if (!SWIG_IsOK(ecode2)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15935 }
15936 arg2 = static_cast< int >(val2);
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 (arg1)->AutoSizeColLabelSize(arg2);
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_Py_Void();
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj = 0;
15952 wxGrid *arg1 = (wxGrid *) 0 ;
15953 int arg2 ;
15954 int arg3 ;
15955 void *argp1 = 0 ;
15956 int res1 = 0 ;
15957 int val2 ;
15958 int ecode2 = 0 ;
15959 int val3 ;
15960 int ecode3 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 char * kwnames[] = {
15965 (char *) "self",(char *) "col",(char *) "width", NULL
15966 };
15967
15968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15970 if (!SWIG_IsOK(res1)) {
15971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15972 }
15973 arg1 = reinterpret_cast< wxGrid * >(argp1);
15974 ecode2 = SWIG_AsVal_int(obj1, &val2);
15975 if (!SWIG_IsOK(ecode2)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15977 }
15978 arg2 = static_cast< int >(val2);
15979 ecode3 = SWIG_AsVal_int(obj2, &val3);
15980 if (!SWIG_IsOK(ecode3)) {
15981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15982 }
15983 arg3 = static_cast< int >(val3);
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 (arg1)->SetColMinimalWidth(arg2,arg3);
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 resultobj = SWIG_Py_Void();
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15998 PyObject *resultobj = 0;
15999 wxGrid *arg1 = (wxGrid *) 0 ;
16000 int arg2 ;
16001 int arg3 ;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 int val2 ;
16005 int ecode2 = 0 ;
16006 int val3 ;
16007 int ecode3 = 0 ;
16008 PyObject * obj0 = 0 ;
16009 PyObject * obj1 = 0 ;
16010 PyObject * obj2 = 0 ;
16011 char * kwnames[] = {
16012 (char *) "self",(char *) "row",(char *) "width", NULL
16013 };
16014
16015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16019 }
16020 arg1 = reinterpret_cast< wxGrid * >(argp1);
16021 ecode2 = SWIG_AsVal_int(obj1, &val2);
16022 if (!SWIG_IsOK(ecode2)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16024 }
16025 arg2 = static_cast< int >(val2);
16026 ecode3 = SWIG_AsVal_int(obj2, &val3);
16027 if (!SWIG_IsOK(ecode3)) {
16028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16029 }
16030 arg3 = static_cast< int >(val3);
16031 {
16032 PyThreadState* __tstate = wxPyBeginAllowThreads();
16033 (arg1)->SetRowMinimalHeight(arg2,arg3);
16034 wxPyEndAllowThreads(__tstate);
16035 if (PyErr_Occurred()) SWIG_fail;
16036 }
16037 resultobj = SWIG_Py_Void();
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16045 PyObject *resultobj = 0;
16046 wxGrid *arg1 = (wxGrid *) 0 ;
16047 int arg2 ;
16048 void *argp1 = 0 ;
16049 int res1 = 0 ;
16050 int val2 ;
16051 int ecode2 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 char * kwnames[] = {
16055 (char *) "self",(char *) "width", NULL
16056 };
16057
16058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16062 }
16063 arg1 = reinterpret_cast< wxGrid * >(argp1);
16064 ecode2 = SWIG_AsVal_int(obj1, &val2);
16065 if (!SWIG_IsOK(ecode2)) {
16066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16067 }
16068 arg2 = static_cast< int >(val2);
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 (arg1)->SetColMinimalAcceptableWidth(arg2);
16072 wxPyEndAllowThreads(__tstate);
16073 if (PyErr_Occurred()) SWIG_fail;
16074 }
16075 resultobj = SWIG_Py_Void();
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16083 PyObject *resultobj = 0;
16084 wxGrid *arg1 = (wxGrid *) 0 ;
16085 int arg2 ;
16086 void *argp1 = 0 ;
16087 int res1 = 0 ;
16088 int val2 ;
16089 int ecode2 = 0 ;
16090 PyObject * obj0 = 0 ;
16091 PyObject * obj1 = 0 ;
16092 char * kwnames[] = {
16093 (char *) "self",(char *) "width", NULL
16094 };
16095
16096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16098 if (!SWIG_IsOK(res1)) {
16099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16100 }
16101 arg1 = reinterpret_cast< wxGrid * >(argp1);
16102 ecode2 = SWIG_AsVal_int(obj1, &val2);
16103 if (!SWIG_IsOK(ecode2)) {
16104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16105 }
16106 arg2 = static_cast< int >(val2);
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 resultobj = SWIG_Py_Void();
16114 return resultobj;
16115 fail:
16116 return NULL;
16117 }
16118
16119
16120 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16121 PyObject *resultobj = 0;
16122 wxGrid *arg1 = (wxGrid *) 0 ;
16123 int result;
16124 void *argp1 = 0 ;
16125 int res1 = 0 ;
16126 PyObject *swig_obj[1] ;
16127
16128 if (!args) SWIG_fail;
16129 swig_obj[0] = args;
16130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16131 if (!SWIG_IsOK(res1)) {
16132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16133 }
16134 arg1 = reinterpret_cast< wxGrid * >(argp1);
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 resultobj = SWIG_From_int(static_cast< int >(result));
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16149 PyObject *resultobj = 0;
16150 wxGrid *arg1 = (wxGrid *) 0 ;
16151 int result;
16152 void *argp1 = 0 ;
16153 int res1 = 0 ;
16154 PyObject *swig_obj[1] ;
16155
16156 if (!args) SWIG_fail;
16157 swig_obj[0] = args;
16158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16161 }
16162 arg1 = reinterpret_cast< wxGrid * >(argp1);
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 resultobj = SWIG_From_int(static_cast< int >(result));
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj = 0;
16178 wxGrid *arg1 = (wxGrid *) 0 ;
16179 wxColour *arg2 = 0 ;
16180 void *argp1 = 0 ;
16181 int res1 = 0 ;
16182 wxColour temp2 ;
16183 PyObject * obj0 = 0 ;
16184 PyObject * obj1 = 0 ;
16185 char * kwnames[] = {
16186 (char *) "self",(char *)"arg2", NULL
16187 };
16188
16189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16191 if (!SWIG_IsOK(res1)) {
16192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16193 }
16194 arg1 = reinterpret_cast< wxGrid * >(argp1);
16195 {
16196 arg2 = &temp2;
16197 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16202 wxPyEndAllowThreads(__tstate);
16203 if (PyErr_Occurred()) SWIG_fail;
16204 }
16205 resultobj = SWIG_Py_Void();
16206 return resultobj;
16207 fail:
16208 return NULL;
16209 }
16210
16211
16212 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16213 PyObject *resultobj = 0;
16214 wxGrid *arg1 = (wxGrid *) 0 ;
16215 int arg2 ;
16216 int arg3 ;
16217 wxColour *arg4 = 0 ;
16218 void *argp1 = 0 ;
16219 int res1 = 0 ;
16220 int val2 ;
16221 int ecode2 = 0 ;
16222 int val3 ;
16223 int ecode3 = 0 ;
16224 wxColour temp4 ;
16225 PyObject * obj0 = 0 ;
16226 PyObject * obj1 = 0 ;
16227 PyObject * obj2 = 0 ;
16228 PyObject * obj3 = 0 ;
16229 char * kwnames[] = {
16230 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16231 };
16232
16233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16235 if (!SWIG_IsOK(res1)) {
16236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16237 }
16238 arg1 = reinterpret_cast< wxGrid * >(argp1);
16239 ecode2 = SWIG_AsVal_int(obj1, &val2);
16240 if (!SWIG_IsOK(ecode2)) {
16241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16242 }
16243 arg2 = static_cast< int >(val2);
16244 ecode3 = SWIG_AsVal_int(obj2, &val3);
16245 if (!SWIG_IsOK(ecode3)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16247 }
16248 arg3 = static_cast< int >(val3);
16249 {
16250 arg4 = &temp4;
16251 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16252 }
16253 {
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16256 wxPyEndAllowThreads(__tstate);
16257 if (PyErr_Occurred()) SWIG_fail;
16258 }
16259 resultobj = SWIG_Py_Void();
16260 return resultobj;
16261 fail:
16262 return NULL;
16263 }
16264
16265
16266 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16267 PyObject *resultobj = 0;
16268 wxGrid *arg1 = (wxGrid *) 0 ;
16269 wxColour *arg2 = 0 ;
16270 void *argp1 = 0 ;
16271 int res1 = 0 ;
16272 wxColour temp2 ;
16273 PyObject * obj0 = 0 ;
16274 PyObject * obj1 = 0 ;
16275 char * kwnames[] = {
16276 (char *) "self",(char *)"arg2", NULL
16277 };
16278
16279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16281 if (!SWIG_IsOK(res1)) {
16282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16283 }
16284 arg1 = reinterpret_cast< wxGrid * >(argp1);
16285 {
16286 arg2 = &temp2;
16287 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16288 }
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 resultobj = SWIG_Py_Void();
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj = 0;
16304 wxGrid *arg1 = (wxGrid *) 0 ;
16305 int arg2 ;
16306 int arg3 ;
16307 wxColour *arg4 = 0 ;
16308 void *argp1 = 0 ;
16309 int res1 = 0 ;
16310 int val2 ;
16311 int ecode2 = 0 ;
16312 int val3 ;
16313 int ecode3 = 0 ;
16314 wxColour temp4 ;
16315 PyObject * obj0 = 0 ;
16316 PyObject * obj1 = 0 ;
16317 PyObject * obj2 = 0 ;
16318 PyObject * obj3 = 0 ;
16319 char * kwnames[] = {
16320 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16321 };
16322
16323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16325 if (!SWIG_IsOK(res1)) {
16326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16327 }
16328 arg1 = reinterpret_cast< wxGrid * >(argp1);
16329 ecode2 = SWIG_AsVal_int(obj1, &val2);
16330 if (!SWIG_IsOK(ecode2)) {
16331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16332 }
16333 arg2 = static_cast< int >(val2);
16334 ecode3 = SWIG_AsVal_int(obj2, &val3);
16335 if (!SWIG_IsOK(ecode3)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16337 }
16338 arg3 = static_cast< int >(val3);
16339 {
16340 arg4 = &temp4;
16341 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16342 }
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16346 wxPyEndAllowThreads(__tstate);
16347 if (PyErr_Occurred()) SWIG_fail;
16348 }
16349 resultobj = SWIG_Py_Void();
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj = 0;
16358 wxGrid *arg1 = (wxGrid *) 0 ;
16359 wxFont *arg2 = 0 ;
16360 void *argp1 = 0 ;
16361 int res1 = 0 ;
16362 void *argp2 = 0 ;
16363 int res2 = 0 ;
16364 PyObject * obj0 = 0 ;
16365 PyObject * obj1 = 0 ;
16366 char * kwnames[] = {
16367 (char *) "self",(char *)"arg2", NULL
16368 };
16369
16370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16372 if (!SWIG_IsOK(res1)) {
16373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16374 }
16375 arg1 = reinterpret_cast< wxGrid * >(argp1);
16376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16377 if (!SWIG_IsOK(res2)) {
16378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16379 }
16380 if (!argp2) {
16381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16382 }
16383 arg2 = reinterpret_cast< wxFont * >(argp2);
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 resultobj = SWIG_Py_Void();
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj = 0;
16399 wxGrid *arg1 = (wxGrid *) 0 ;
16400 int arg2 ;
16401 int arg3 ;
16402 wxFont *arg4 = 0 ;
16403 void *argp1 = 0 ;
16404 int res1 = 0 ;
16405 int val2 ;
16406 int ecode2 = 0 ;
16407 int val3 ;
16408 int ecode3 = 0 ;
16409 void *argp4 = 0 ;
16410 int res4 = 0 ;
16411 PyObject * obj0 = 0 ;
16412 PyObject * obj1 = 0 ;
16413 PyObject * obj2 = 0 ;
16414 PyObject * obj3 = 0 ;
16415 char * kwnames[] = {
16416 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16417 };
16418
16419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16421 if (!SWIG_IsOK(res1)) {
16422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16423 }
16424 arg1 = reinterpret_cast< wxGrid * >(argp1);
16425 ecode2 = SWIG_AsVal_int(obj1, &val2);
16426 if (!SWIG_IsOK(ecode2)) {
16427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16428 }
16429 arg2 = static_cast< int >(val2);
16430 ecode3 = SWIG_AsVal_int(obj2, &val3);
16431 if (!SWIG_IsOK(ecode3)) {
16432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16433 }
16434 arg3 = static_cast< int >(val3);
16435 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16436 if (!SWIG_IsOK(res4)) {
16437 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16438 }
16439 if (!argp4) {
16440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16441 }
16442 arg4 = reinterpret_cast< wxFont * >(argp4);
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_Py_Void();
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj = 0;
16458 wxGrid *arg1 = (wxGrid *) 0 ;
16459 int arg2 ;
16460 int arg3 ;
16461 void *argp1 = 0 ;
16462 int res1 = 0 ;
16463 int val2 ;
16464 int ecode2 = 0 ;
16465 int val3 ;
16466 int ecode3 = 0 ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 PyObject * obj2 = 0 ;
16470 char * kwnames[] = {
16471 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16472 };
16473
16474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16476 if (!SWIG_IsOK(res1)) {
16477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16478 }
16479 arg1 = reinterpret_cast< wxGrid * >(argp1);
16480 ecode2 = SWIG_AsVal_int(obj1, &val2);
16481 if (!SWIG_IsOK(ecode2)) {
16482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16483 }
16484 arg2 = static_cast< int >(val2);
16485 ecode3 = SWIG_AsVal_int(obj2, &val3);
16486 if (!SWIG_IsOK(ecode3)) {
16487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16488 }
16489 arg3 = static_cast< int >(val3);
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_Py_Void();
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 wxGrid *arg1 = (wxGrid *) 0 ;
16506 int arg2 ;
16507 int arg3 ;
16508 int arg4 ;
16509 int arg5 ;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 int val2 ;
16513 int ecode2 = 0 ;
16514 int val3 ;
16515 int ecode3 = 0 ;
16516 int val4 ;
16517 int ecode4 = 0 ;
16518 int val5 ;
16519 int ecode5 = 0 ;
16520 PyObject * obj0 = 0 ;
16521 PyObject * obj1 = 0 ;
16522 PyObject * obj2 = 0 ;
16523 PyObject * obj3 = 0 ;
16524 PyObject * obj4 = 0 ;
16525 char * kwnames[] = {
16526 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16527 };
16528
16529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16531 if (!SWIG_IsOK(res1)) {
16532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16533 }
16534 arg1 = reinterpret_cast< wxGrid * >(argp1);
16535 ecode2 = SWIG_AsVal_int(obj1, &val2);
16536 if (!SWIG_IsOK(ecode2)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16538 }
16539 arg2 = static_cast< int >(val2);
16540 ecode3 = SWIG_AsVal_int(obj2, &val3);
16541 if (!SWIG_IsOK(ecode3)) {
16542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16543 }
16544 arg3 = static_cast< int >(val3);
16545 ecode4 = SWIG_AsVal_int(obj3, &val4);
16546 if (!SWIG_IsOK(ecode4)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16548 }
16549 arg4 = static_cast< int >(val4);
16550 ecode5 = SWIG_AsVal_int(obj4, &val5);
16551 if (!SWIG_IsOK(ecode5)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16553 }
16554 arg5 = static_cast< int >(val5);
16555 {
16556 PyThreadState* __tstate = wxPyBeginAllowThreads();
16557 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 resultobj = SWIG_Py_Void();
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj = 0;
16570 wxGrid *arg1 = (wxGrid *) 0 ;
16571 bool arg2 ;
16572 void *argp1 = 0 ;
16573 int res1 = 0 ;
16574 bool val2 ;
16575 int ecode2 = 0 ;
16576 PyObject * obj0 = 0 ;
16577 PyObject * obj1 = 0 ;
16578 char * kwnames[] = {
16579 (char *) "self",(char *) "allow", NULL
16580 };
16581
16582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16584 if (!SWIG_IsOK(res1)) {
16585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16586 }
16587 arg1 = reinterpret_cast< wxGrid * >(argp1);
16588 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16589 if (!SWIG_IsOK(ecode2)) {
16590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16591 }
16592 arg2 = static_cast< bool >(val2);
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 (arg1)->SetDefaultCellOverflow(arg2);
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 resultobj = SWIG_Py_Void();
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj = 0;
16608 wxGrid *arg1 = (wxGrid *) 0 ;
16609 int arg2 ;
16610 int arg3 ;
16611 bool arg4 ;
16612 void *argp1 = 0 ;
16613 int res1 = 0 ;
16614 int val2 ;
16615 int ecode2 = 0 ;
16616 int val3 ;
16617 int ecode3 = 0 ;
16618 bool val4 ;
16619 int ecode4 = 0 ;
16620 PyObject * obj0 = 0 ;
16621 PyObject * obj1 = 0 ;
16622 PyObject * obj2 = 0 ;
16623 PyObject * obj3 = 0 ;
16624 char * kwnames[] = {
16625 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16626 };
16627
16628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16630 if (!SWIG_IsOK(res1)) {
16631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16632 }
16633 arg1 = reinterpret_cast< wxGrid * >(argp1);
16634 ecode2 = SWIG_AsVal_int(obj1, &val2);
16635 if (!SWIG_IsOK(ecode2)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16637 }
16638 arg2 = static_cast< int >(val2);
16639 ecode3 = SWIG_AsVal_int(obj2, &val3);
16640 if (!SWIG_IsOK(ecode3)) {
16641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16642 }
16643 arg3 = static_cast< int >(val3);
16644 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16645 if (!SWIG_IsOK(ecode4)) {
16646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16647 }
16648 arg4 = static_cast< bool >(val4);
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16652 wxPyEndAllowThreads(__tstate);
16653 if (PyErr_Occurred()) SWIG_fail;
16654 }
16655 resultobj = SWIG_Py_Void();
16656 return resultobj;
16657 fail:
16658 return NULL;
16659 }
16660
16661
16662 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16663 PyObject *resultobj = 0;
16664 wxGrid *arg1 = (wxGrid *) 0 ;
16665 int arg2 ;
16666 int arg3 ;
16667 int arg4 ;
16668 int arg5 ;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 int val2 ;
16672 int ecode2 = 0 ;
16673 int val3 ;
16674 int ecode3 = 0 ;
16675 int val4 ;
16676 int ecode4 = 0 ;
16677 int val5 ;
16678 int ecode5 = 0 ;
16679 PyObject * obj0 = 0 ;
16680 PyObject * obj1 = 0 ;
16681 PyObject * obj2 = 0 ;
16682 PyObject * obj3 = 0 ;
16683 PyObject * obj4 = 0 ;
16684 char * kwnames[] = {
16685 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16686 };
16687
16688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16690 if (!SWIG_IsOK(res1)) {
16691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16692 }
16693 arg1 = reinterpret_cast< wxGrid * >(argp1);
16694 ecode2 = SWIG_AsVal_int(obj1, &val2);
16695 if (!SWIG_IsOK(ecode2)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16697 }
16698 arg2 = static_cast< int >(val2);
16699 ecode3 = SWIG_AsVal_int(obj2, &val3);
16700 if (!SWIG_IsOK(ecode3)) {
16701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16702 }
16703 arg3 = static_cast< int >(val3);
16704 ecode4 = SWIG_AsVal_int(obj3, &val4);
16705 if (!SWIG_IsOK(ecode4)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16707 }
16708 arg4 = static_cast< int >(val4);
16709 ecode5 = SWIG_AsVal_int(obj4, &val5);
16710 if (!SWIG_IsOK(ecode5)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16712 }
16713 arg5 = static_cast< int >(val5);
16714 {
16715 PyThreadState* __tstate = wxPyBeginAllowThreads();
16716 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 resultobj = SWIG_Py_Void();
16721 return resultobj;
16722 fail:
16723 return NULL;
16724 }
16725
16726
16727 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16728 PyObject *resultobj = 0;
16729 wxGrid *arg1 = (wxGrid *) 0 ;
16730 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16731 void *argp1 = 0 ;
16732 int res1 = 0 ;
16733 void *argp2 = 0 ;
16734 int res2 = 0 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 char * kwnames[] = {
16738 (char *) "self",(char *) "renderer", NULL
16739 };
16740
16741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16743 if (!SWIG_IsOK(res1)) {
16744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16745 }
16746 arg1 = reinterpret_cast< wxGrid * >(argp1);
16747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16748 if (!SWIG_IsOK(res2)) {
16749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16750 }
16751 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 (arg1)->SetDefaultRenderer(arg2);
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 resultobj = SWIG_Py_Void();
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16766 PyObject *resultobj = 0;
16767 wxGrid *arg1 = (wxGrid *) 0 ;
16768 int arg2 ;
16769 int arg3 ;
16770 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16771 void *argp1 = 0 ;
16772 int res1 = 0 ;
16773 int val2 ;
16774 int ecode2 = 0 ;
16775 int val3 ;
16776 int ecode3 = 0 ;
16777 void *argp4 = 0 ;
16778 int res4 = 0 ;
16779 PyObject * obj0 = 0 ;
16780 PyObject * obj1 = 0 ;
16781 PyObject * obj2 = 0 ;
16782 PyObject * obj3 = 0 ;
16783 char * kwnames[] = {
16784 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16785 };
16786
16787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16789 if (!SWIG_IsOK(res1)) {
16790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16791 }
16792 arg1 = reinterpret_cast< wxGrid * >(argp1);
16793 ecode2 = SWIG_AsVal_int(obj1, &val2);
16794 if (!SWIG_IsOK(ecode2)) {
16795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16796 }
16797 arg2 = static_cast< int >(val2);
16798 ecode3 = SWIG_AsVal_int(obj2, &val3);
16799 if (!SWIG_IsOK(ecode3)) {
16800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16801 }
16802 arg3 = static_cast< int >(val3);
16803 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16804 if (!SWIG_IsOK(res4)) {
16805 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16806 }
16807 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_Py_Void();
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16822 PyObject *resultobj = 0;
16823 wxGrid *arg1 = (wxGrid *) 0 ;
16824 wxGridCellRenderer *result = 0 ;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 PyObject *swig_obj[1] ;
16828
16829 if (!args) SWIG_fail;
16830 swig_obj[0] = args;
16831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16834 }
16835 arg1 = reinterpret_cast< wxGrid * >(argp1);
16836 {
16837 PyThreadState* __tstate = wxPyBeginAllowThreads();
16838 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16839 wxPyEndAllowThreads(__tstate);
16840 if (PyErr_Occurred()) SWIG_fail;
16841 }
16842 {
16843 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16844 }
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxGrid *arg1 = (wxGrid *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 wxGridCellRenderer *result = 0 ;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 PyObject * obj2 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "row",(char *) "col", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16874 }
16875 arg1 = reinterpret_cast< wxGrid * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 ecode3 = SWIG_AsVal_int(obj2, &val3);
16882 if (!SWIG_IsOK(ecode3)) {
16883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16884 }
16885 arg3 = static_cast< int >(val3);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 {
16893 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16894 }
16895 return resultobj;
16896 fail:
16897 return NULL;
16898 }
16899
16900
16901 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16902 PyObject *resultobj = 0;
16903 wxGrid *arg1 = (wxGrid *) 0 ;
16904 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16905 void *argp1 = 0 ;
16906 int res1 = 0 ;
16907 void *argp2 = 0 ;
16908 int res2 = 0 ;
16909 PyObject * obj0 = 0 ;
16910 PyObject * obj1 = 0 ;
16911 char * kwnames[] = {
16912 (char *) "self",(char *) "editor", NULL
16913 };
16914
16915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16917 if (!SWIG_IsOK(res1)) {
16918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16919 }
16920 arg1 = reinterpret_cast< wxGrid * >(argp1);
16921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16922 if (!SWIG_IsOK(res2)) {
16923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16924 }
16925 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 (arg1)->SetDefaultEditor(arg2);
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 resultobj = SWIG_Py_Void();
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj = 0;
16941 wxGrid *arg1 = (wxGrid *) 0 ;
16942 int arg2 ;
16943 int arg3 ;
16944 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16945 void *argp1 = 0 ;
16946 int res1 = 0 ;
16947 int val2 ;
16948 int ecode2 = 0 ;
16949 int val3 ;
16950 int ecode3 = 0 ;
16951 void *argp4 = 0 ;
16952 int res4 = 0 ;
16953 PyObject * obj0 = 0 ;
16954 PyObject * obj1 = 0 ;
16955 PyObject * obj2 = 0 ;
16956 PyObject * obj3 = 0 ;
16957 char * kwnames[] = {
16958 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16959 };
16960
16961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16963 if (!SWIG_IsOK(res1)) {
16964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16965 }
16966 arg1 = reinterpret_cast< wxGrid * >(argp1);
16967 ecode2 = SWIG_AsVal_int(obj1, &val2);
16968 if (!SWIG_IsOK(ecode2)) {
16969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16970 }
16971 arg2 = static_cast< int >(val2);
16972 ecode3 = SWIG_AsVal_int(obj2, &val3);
16973 if (!SWIG_IsOK(ecode3)) {
16974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16975 }
16976 arg3 = static_cast< int >(val3);
16977 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16978 if (!SWIG_IsOK(res4)) {
16979 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16980 }
16981 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 (arg1)->SetCellEditor(arg2,arg3,arg4);
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 resultobj = SWIG_Py_Void();
16989 return resultobj;
16990 fail:
16991 return NULL;
16992 }
16993
16994
16995 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16996 PyObject *resultobj = 0;
16997 wxGrid *arg1 = (wxGrid *) 0 ;
16998 wxGridCellEditor *result = 0 ;
16999 void *argp1 = 0 ;
17000 int res1 = 0 ;
17001 PyObject *swig_obj[1] ;
17002
17003 if (!args) SWIG_fail;
17004 swig_obj[0] = args;
17005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17008 }
17009 arg1 = reinterpret_cast< wxGrid * >(argp1);
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 {
17017 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17018 }
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj = 0;
17027 wxGrid *arg1 = (wxGrid *) 0 ;
17028 int arg2 ;
17029 int arg3 ;
17030 wxGridCellEditor *result = 0 ;
17031 void *argp1 = 0 ;
17032 int res1 = 0 ;
17033 int val2 ;
17034 int ecode2 = 0 ;
17035 int val3 ;
17036 int ecode3 = 0 ;
17037 PyObject * obj0 = 0 ;
17038 PyObject * obj1 = 0 ;
17039 PyObject * obj2 = 0 ;
17040 char * kwnames[] = {
17041 (char *) "self",(char *) "row",(char *) "col", NULL
17042 };
17043
17044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17046 if (!SWIG_IsOK(res1)) {
17047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17048 }
17049 arg1 = reinterpret_cast< wxGrid * >(argp1);
17050 ecode2 = SWIG_AsVal_int(obj1, &val2);
17051 if (!SWIG_IsOK(ecode2)) {
17052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17053 }
17054 arg2 = static_cast< int >(val2);
17055 ecode3 = SWIG_AsVal_int(obj2, &val3);
17056 if (!SWIG_IsOK(ecode3)) {
17057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17058 }
17059 arg3 = static_cast< int >(val3);
17060 {
17061 PyThreadState* __tstate = wxPyBeginAllowThreads();
17062 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17063 wxPyEndAllowThreads(__tstate);
17064 if (PyErr_Occurred()) SWIG_fail;
17065 }
17066 {
17067 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17068 }
17069 return resultobj;
17070 fail:
17071 return NULL;
17072 }
17073
17074
17075 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17076 PyObject *resultobj = 0;
17077 wxGrid *arg1 = (wxGrid *) 0 ;
17078 int arg2 ;
17079 int arg3 ;
17080 wxString result;
17081 void *argp1 = 0 ;
17082 int res1 = 0 ;
17083 int val2 ;
17084 int ecode2 = 0 ;
17085 int val3 ;
17086 int ecode3 = 0 ;
17087 PyObject * obj0 = 0 ;
17088 PyObject * obj1 = 0 ;
17089 PyObject * obj2 = 0 ;
17090 char * kwnames[] = {
17091 (char *) "self",(char *) "row",(char *) "col", NULL
17092 };
17093
17094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17096 if (!SWIG_IsOK(res1)) {
17097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17098 }
17099 arg1 = reinterpret_cast< wxGrid * >(argp1);
17100 ecode2 = SWIG_AsVal_int(obj1, &val2);
17101 if (!SWIG_IsOK(ecode2)) {
17102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17103 }
17104 arg2 = static_cast< int >(val2);
17105 ecode3 = SWIG_AsVal_int(obj2, &val3);
17106 if (!SWIG_IsOK(ecode3)) {
17107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17108 }
17109 arg3 = static_cast< int >(val3);
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (arg1)->GetCellValue(arg2,arg3);
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 {
17117 #if wxUSE_UNICODE
17118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17119 #else
17120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17121 #endif
17122 }
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj = 0;
17131 wxGrid *arg1 = (wxGrid *) 0 ;
17132 int arg2 ;
17133 int arg3 ;
17134 wxString *arg4 = 0 ;
17135 void *argp1 = 0 ;
17136 int res1 = 0 ;
17137 int val2 ;
17138 int ecode2 = 0 ;
17139 int val3 ;
17140 int ecode3 = 0 ;
17141 bool temp4 = false ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 PyObject * obj2 = 0 ;
17145 PyObject * obj3 = 0 ;
17146 char * kwnames[] = {
17147 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17148 };
17149
17150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17152 if (!SWIG_IsOK(res1)) {
17153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17154 }
17155 arg1 = reinterpret_cast< wxGrid * >(argp1);
17156 ecode2 = SWIG_AsVal_int(obj1, &val2);
17157 if (!SWIG_IsOK(ecode2)) {
17158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17159 }
17160 arg2 = static_cast< int >(val2);
17161 ecode3 = SWIG_AsVal_int(obj2, &val3);
17162 if (!SWIG_IsOK(ecode3)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17164 }
17165 arg3 = static_cast< int >(val3);
17166 {
17167 arg4 = wxString_in_helper(obj3);
17168 if (arg4 == NULL) SWIG_fail;
17169 temp4 = true;
17170 }
17171 {
17172 PyThreadState* __tstate = wxPyBeginAllowThreads();
17173 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 resultobj = SWIG_Py_Void();
17178 {
17179 if (temp4)
17180 delete arg4;
17181 }
17182 return resultobj;
17183 fail:
17184 {
17185 if (temp4)
17186 delete arg4;
17187 }
17188 return NULL;
17189 }
17190
17191
17192 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17193 PyObject *resultobj = 0;
17194 wxGrid *arg1 = (wxGrid *) 0 ;
17195 int arg2 ;
17196 int arg3 ;
17197 bool result;
17198 void *argp1 = 0 ;
17199 int res1 = 0 ;
17200 int val2 ;
17201 int ecode2 = 0 ;
17202 int val3 ;
17203 int ecode3 = 0 ;
17204 PyObject * obj0 = 0 ;
17205 PyObject * obj1 = 0 ;
17206 PyObject * obj2 = 0 ;
17207 char * kwnames[] = {
17208 (char *) "self",(char *) "row",(char *) "col", NULL
17209 };
17210
17211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17213 if (!SWIG_IsOK(res1)) {
17214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17215 }
17216 arg1 = reinterpret_cast< wxGrid * >(argp1);
17217 ecode2 = SWIG_AsVal_int(obj1, &val2);
17218 if (!SWIG_IsOK(ecode2)) {
17219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17220 }
17221 arg2 = static_cast< int >(val2);
17222 ecode3 = SWIG_AsVal_int(obj2, &val3);
17223 if (!SWIG_IsOK(ecode3)) {
17224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17225 }
17226 arg3 = static_cast< int >(val3);
17227 {
17228 PyThreadState* __tstate = wxPyBeginAllowThreads();
17229 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 {
17234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17235 }
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj = 0;
17244 wxGrid *arg1 = (wxGrid *) 0 ;
17245 int arg2 ;
17246 int arg3 ;
17247 bool arg4 = (bool) true ;
17248 void *argp1 = 0 ;
17249 int res1 = 0 ;
17250 int val2 ;
17251 int ecode2 = 0 ;
17252 int val3 ;
17253 int ecode3 = 0 ;
17254 bool val4 ;
17255 int ecode4 = 0 ;
17256 PyObject * obj0 = 0 ;
17257 PyObject * obj1 = 0 ;
17258 PyObject * obj2 = 0 ;
17259 PyObject * obj3 = 0 ;
17260 char * kwnames[] = {
17261 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17262 };
17263
17264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17266 if (!SWIG_IsOK(res1)) {
17267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17268 }
17269 arg1 = reinterpret_cast< wxGrid * >(argp1);
17270 ecode2 = SWIG_AsVal_int(obj1, &val2);
17271 if (!SWIG_IsOK(ecode2)) {
17272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17273 }
17274 arg2 = static_cast< int >(val2);
17275 ecode3 = SWIG_AsVal_int(obj2, &val3);
17276 if (!SWIG_IsOK(ecode3)) {
17277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17278 }
17279 arg3 = static_cast< int >(val3);
17280 if (obj3) {
17281 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17282 if (!SWIG_IsOK(ecode4)) {
17283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17284 }
17285 arg4 = static_cast< bool >(val4);
17286 }
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 (arg1)->SetReadOnly(arg2,arg3,arg4);
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 resultobj = SWIG_Py_Void();
17294 return resultobj;
17295 fail:
17296 return NULL;
17297 }
17298
17299
17300 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17301 PyObject *resultobj = 0;
17302 wxGrid *arg1 = (wxGrid *) 0 ;
17303 int arg2 ;
17304 bool arg3 = (bool) false ;
17305 void *argp1 = 0 ;
17306 int res1 = 0 ;
17307 int val2 ;
17308 int ecode2 = 0 ;
17309 bool val3 ;
17310 int ecode3 = 0 ;
17311 PyObject * obj0 = 0 ;
17312 PyObject * obj1 = 0 ;
17313 PyObject * obj2 = 0 ;
17314 char * kwnames[] = {
17315 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17316 };
17317
17318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17320 if (!SWIG_IsOK(res1)) {
17321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17322 }
17323 arg1 = reinterpret_cast< wxGrid * >(argp1);
17324 ecode2 = SWIG_AsVal_int(obj1, &val2);
17325 if (!SWIG_IsOK(ecode2)) {
17326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17327 }
17328 arg2 = static_cast< int >(val2);
17329 if (obj2) {
17330 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17331 if (!SWIG_IsOK(ecode3)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17333 }
17334 arg3 = static_cast< bool >(val3);
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 (arg1)->SelectRow(arg2,arg3);
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_Py_Void();
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj = 0;
17351 wxGrid *arg1 = (wxGrid *) 0 ;
17352 int arg2 ;
17353 bool arg3 = (bool) false ;
17354 void *argp1 = 0 ;
17355 int res1 = 0 ;
17356 int val2 ;
17357 int ecode2 = 0 ;
17358 bool val3 ;
17359 int ecode3 = 0 ;
17360 PyObject * obj0 = 0 ;
17361 PyObject * obj1 = 0 ;
17362 PyObject * obj2 = 0 ;
17363 char * kwnames[] = {
17364 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17365 };
17366
17367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17369 if (!SWIG_IsOK(res1)) {
17370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17371 }
17372 arg1 = reinterpret_cast< wxGrid * >(argp1);
17373 ecode2 = SWIG_AsVal_int(obj1, &val2);
17374 if (!SWIG_IsOK(ecode2)) {
17375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17376 }
17377 arg2 = static_cast< int >(val2);
17378 if (obj2) {
17379 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17380 if (!SWIG_IsOK(ecode3)) {
17381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17382 }
17383 arg3 = static_cast< bool >(val3);
17384 }
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 (arg1)->SelectCol(arg2,arg3);
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_Py_Void();
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17399 PyObject *resultobj = 0;
17400 wxGrid *arg1 = (wxGrid *) 0 ;
17401 int arg2 ;
17402 int arg3 ;
17403 int arg4 ;
17404 int arg5 ;
17405 bool arg6 = (bool) false ;
17406 void *argp1 = 0 ;
17407 int res1 = 0 ;
17408 int val2 ;
17409 int ecode2 = 0 ;
17410 int val3 ;
17411 int ecode3 = 0 ;
17412 int val4 ;
17413 int ecode4 = 0 ;
17414 int val5 ;
17415 int ecode5 = 0 ;
17416 bool val6 ;
17417 int ecode6 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 PyObject * obj3 = 0 ;
17422 PyObject * obj4 = 0 ;
17423 PyObject * obj5 = 0 ;
17424 char * kwnames[] = {
17425 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17426 };
17427
17428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17430 if (!SWIG_IsOK(res1)) {
17431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17432 }
17433 arg1 = reinterpret_cast< wxGrid * >(argp1);
17434 ecode2 = SWIG_AsVal_int(obj1, &val2);
17435 if (!SWIG_IsOK(ecode2)) {
17436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17437 }
17438 arg2 = static_cast< int >(val2);
17439 ecode3 = SWIG_AsVal_int(obj2, &val3);
17440 if (!SWIG_IsOK(ecode3)) {
17441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17442 }
17443 arg3 = static_cast< int >(val3);
17444 ecode4 = SWIG_AsVal_int(obj3, &val4);
17445 if (!SWIG_IsOK(ecode4)) {
17446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17447 }
17448 arg4 = static_cast< int >(val4);
17449 ecode5 = SWIG_AsVal_int(obj4, &val5);
17450 if (!SWIG_IsOK(ecode5)) {
17451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17452 }
17453 arg5 = static_cast< int >(val5);
17454 if (obj5) {
17455 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17456 if (!SWIG_IsOK(ecode6)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17458 }
17459 arg6 = static_cast< bool >(val6);
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_Py_Void();
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *resultobj = 0;
17476 wxGrid *arg1 = (wxGrid *) 0 ;
17477 void *argp1 = 0 ;
17478 int res1 = 0 ;
17479 PyObject *swig_obj[1] ;
17480
17481 if (!args) SWIG_fail;
17482 swig_obj[0] = args;
17483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17484 if (!SWIG_IsOK(res1)) {
17485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17486 }
17487 arg1 = reinterpret_cast< wxGrid * >(argp1);
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 (arg1)->SelectAll();
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 resultobj = SWIG_Py_Void();
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *resultobj = 0;
17503 wxGrid *arg1 = (wxGrid *) 0 ;
17504 bool result;
17505 void *argp1 = 0 ;
17506 int res1 = 0 ;
17507 PyObject *swig_obj[1] ;
17508
17509 if (!args) SWIG_fail;
17510 swig_obj[0] = args;
17511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17512 if (!SWIG_IsOK(res1)) {
17513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17514 }
17515 arg1 = reinterpret_cast< wxGrid * >(argp1);
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (bool)(arg1)->IsSelection();
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 {
17523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17524 }
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxGrid *arg1 = (wxGrid *) 0 ;
17534 void *argp1 = 0 ;
17535 int res1 = 0 ;
17536 PyObject *swig_obj[1] ;
17537
17538 if (!args) SWIG_fail;
17539 swig_obj[0] = args;
17540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17541 if (!SWIG_IsOK(res1)) {
17542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17543 }
17544 arg1 = reinterpret_cast< wxGrid * >(argp1);
17545 {
17546 PyThreadState* __tstate = wxPyBeginAllowThreads();
17547 (arg1)->ClearSelection();
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 resultobj = SWIG_Py_Void();
17552 return resultobj;
17553 fail:
17554 return NULL;
17555 }
17556
17557
17558 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj = 0;
17560 wxGrid *arg1 = (wxGrid *) 0 ;
17561 int arg2 ;
17562 int arg3 ;
17563 bool result;
17564 void *argp1 = 0 ;
17565 int res1 = 0 ;
17566 int val2 ;
17567 int ecode2 = 0 ;
17568 int val3 ;
17569 int ecode3 = 0 ;
17570 PyObject * obj0 = 0 ;
17571 PyObject * obj1 = 0 ;
17572 PyObject * obj2 = 0 ;
17573 char * kwnames[] = {
17574 (char *) "self",(char *) "row",(char *) "col", NULL
17575 };
17576
17577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17579 if (!SWIG_IsOK(res1)) {
17580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17581 }
17582 arg1 = reinterpret_cast< wxGrid * >(argp1);
17583 ecode2 = SWIG_AsVal_int(obj1, &val2);
17584 if (!SWIG_IsOK(ecode2)) {
17585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17586 }
17587 arg2 = static_cast< int >(val2);
17588 ecode3 = SWIG_AsVal_int(obj2, &val3);
17589 if (!SWIG_IsOK(ecode3)) {
17590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17591 }
17592 arg3 = static_cast< int >(val3);
17593 {
17594 PyThreadState* __tstate = wxPyBeginAllowThreads();
17595 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17601 }
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 PyObject *resultobj = 0;
17610 wxGrid *arg1 = (wxGrid *) 0 ;
17611 wxGridCellCoordsArray result;
17612 void *argp1 = 0 ;
17613 int res1 = 0 ;
17614 PyObject *swig_obj[1] ;
17615
17616 if (!args) SWIG_fail;
17617 swig_obj[0] = args;
17618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17619 if (!SWIG_IsOK(res1)) {
17620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17621 }
17622 arg1 = reinterpret_cast< wxGrid * >(argp1);
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = ((wxGrid const *)arg1)->GetSelectedCells();
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = wxGridCellCoordsArray_helper(result);
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *resultobj = 0;
17640 wxGrid *arg1 = (wxGrid *) 0 ;
17641 wxGridCellCoordsArray result;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 PyObject *swig_obj[1] ;
17645
17646 if (!args) SWIG_fail;
17647 swig_obj[0] = args;
17648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17651 }
17652 arg1 = reinterpret_cast< wxGrid * >(argp1);
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 resultobj = wxGridCellCoordsArray_helper(result);
17661 }
17662 return resultobj;
17663 fail:
17664 return NULL;
17665 }
17666
17667
17668 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17669 PyObject *resultobj = 0;
17670 wxGrid *arg1 = (wxGrid *) 0 ;
17671 wxGridCellCoordsArray result;
17672 void *argp1 = 0 ;
17673 int res1 = 0 ;
17674 PyObject *swig_obj[1] ;
17675
17676 if (!args) SWIG_fail;
17677 swig_obj[0] = args;
17678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17679 if (!SWIG_IsOK(res1)) {
17680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17681 }
17682 arg1 = reinterpret_cast< wxGrid * >(argp1);
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = wxGridCellCoordsArray_helper(result);
17691 }
17692 return resultobj;
17693 fail:
17694 return NULL;
17695 }
17696
17697
17698 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17699 PyObject *resultobj = 0;
17700 wxGrid *arg1 = (wxGrid *) 0 ;
17701 wxArrayInt result;
17702 void *argp1 = 0 ;
17703 int res1 = 0 ;
17704 PyObject *swig_obj[1] ;
17705
17706 if (!args) SWIG_fail;
17707 swig_obj[0] = args;
17708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17711 }
17712 arg1 = reinterpret_cast< wxGrid * >(argp1);
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 result = ((wxGrid const *)arg1)->GetSelectedRows();
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 {
17720 resultobj = PyList_New(0);
17721 size_t idx;
17722 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17723 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17724 PyList_Append(resultobj, val);
17725 Py_DECREF(val);
17726 }
17727 }
17728 return resultobj;
17729 fail:
17730 return NULL;
17731 }
17732
17733
17734 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17735 PyObject *resultobj = 0;
17736 wxGrid *arg1 = (wxGrid *) 0 ;
17737 wxArrayInt result;
17738 void *argp1 = 0 ;
17739 int res1 = 0 ;
17740 PyObject *swig_obj[1] ;
17741
17742 if (!args) SWIG_fail;
17743 swig_obj[0] = args;
17744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17745 if (!SWIG_IsOK(res1)) {
17746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17747 }
17748 arg1 = reinterpret_cast< wxGrid * >(argp1);
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = ((wxGrid const *)arg1)->GetSelectedCols();
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 resultobj = PyList_New(0);
17757 size_t idx;
17758 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17759 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17760 PyList_Append(resultobj, val);
17761 Py_DECREF(val);
17762 }
17763 }
17764 return resultobj;
17765 fail:
17766 return NULL;
17767 }
17768
17769
17770 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17771 PyObject *resultobj = 0;
17772 wxGrid *arg1 = (wxGrid *) 0 ;
17773 int arg2 ;
17774 void *argp1 = 0 ;
17775 int res1 = 0 ;
17776 int val2 ;
17777 int ecode2 = 0 ;
17778 PyObject * obj0 = 0 ;
17779 PyObject * obj1 = 0 ;
17780 char * kwnames[] = {
17781 (char *) "self",(char *) "row", NULL
17782 };
17783
17784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17786 if (!SWIG_IsOK(res1)) {
17787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17788 }
17789 arg1 = reinterpret_cast< wxGrid * >(argp1);
17790 ecode2 = SWIG_AsVal_int(obj1, &val2);
17791 if (!SWIG_IsOK(ecode2)) {
17792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17793 }
17794 arg2 = static_cast< int >(val2);
17795 {
17796 PyThreadState* __tstate = wxPyBeginAllowThreads();
17797 (arg1)->DeselectRow(arg2);
17798 wxPyEndAllowThreads(__tstate);
17799 if (PyErr_Occurred()) SWIG_fail;
17800 }
17801 resultobj = SWIG_Py_Void();
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj = 0;
17810 wxGrid *arg1 = (wxGrid *) 0 ;
17811 int arg2 ;
17812 void *argp1 = 0 ;
17813 int res1 = 0 ;
17814 int val2 ;
17815 int ecode2 = 0 ;
17816 PyObject * obj0 = 0 ;
17817 PyObject * obj1 = 0 ;
17818 char * kwnames[] = {
17819 (char *) "self",(char *) "col", NULL
17820 };
17821
17822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17824 if (!SWIG_IsOK(res1)) {
17825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17826 }
17827 arg1 = reinterpret_cast< wxGrid * >(argp1);
17828 ecode2 = SWIG_AsVal_int(obj1, &val2);
17829 if (!SWIG_IsOK(ecode2)) {
17830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17831 }
17832 arg2 = static_cast< int >(val2);
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 (arg1)->DeselectCol(arg2);
17836 wxPyEndAllowThreads(__tstate);
17837 if (PyErr_Occurred()) SWIG_fail;
17838 }
17839 resultobj = SWIG_Py_Void();
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17847 PyObject *resultobj = 0;
17848 wxGrid *arg1 = (wxGrid *) 0 ;
17849 int arg2 ;
17850 int arg3 ;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 int val2 ;
17854 int ecode2 = 0 ;
17855 int val3 ;
17856 int ecode3 = 0 ;
17857 PyObject * obj0 = 0 ;
17858 PyObject * obj1 = 0 ;
17859 PyObject * obj2 = 0 ;
17860 char * kwnames[] = {
17861 (char *) "self",(char *) "row",(char *) "col", NULL
17862 };
17863
17864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17866 if (!SWIG_IsOK(res1)) {
17867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17868 }
17869 arg1 = reinterpret_cast< wxGrid * >(argp1);
17870 ecode2 = SWIG_AsVal_int(obj1, &val2);
17871 if (!SWIG_IsOK(ecode2)) {
17872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17873 }
17874 arg2 = static_cast< int >(val2);
17875 ecode3 = SWIG_AsVal_int(obj2, &val3);
17876 if (!SWIG_IsOK(ecode3)) {
17877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17878 }
17879 arg3 = static_cast< int >(val3);
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 (arg1)->DeselectCell(arg2,arg3);
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 resultobj = SWIG_Py_Void();
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj = 0;
17895 wxGrid *arg1 = (wxGrid *) 0 ;
17896 wxGridCellCoords *arg2 = 0 ;
17897 wxGridCellCoords *arg3 = 0 ;
17898 wxRect result;
17899 void *argp1 = 0 ;
17900 int res1 = 0 ;
17901 wxGridCellCoords temp2 ;
17902 wxGridCellCoords temp3 ;
17903 PyObject * obj0 = 0 ;
17904 PyObject * obj1 = 0 ;
17905 PyObject * obj2 = 0 ;
17906 char * kwnames[] = {
17907 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17908 };
17909
17910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17914 }
17915 arg1 = reinterpret_cast< wxGrid * >(argp1);
17916 {
17917 arg2 = &temp2;
17918 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17919 }
17920 {
17921 arg3 = &temp3;
17922 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17923 }
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17938 PyObject *resultobj = 0;
17939 wxGrid *arg1 = (wxGrid *) 0 ;
17940 wxColour result;
17941 void *argp1 = 0 ;
17942 int res1 = 0 ;
17943 PyObject *swig_obj[1] ;
17944
17945 if (!args) SWIG_fail;
17946 swig_obj[0] = args;
17947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17948 if (!SWIG_IsOK(res1)) {
17949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17950 }
17951 arg1 = reinterpret_cast< wxGrid * >(argp1);
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *resultobj = 0;
17967 wxGrid *arg1 = (wxGrid *) 0 ;
17968 wxColour result;
17969 void *argp1 = 0 ;
17970 int res1 = 0 ;
17971 PyObject *swig_obj[1] ;
17972
17973 if (!args) SWIG_fail;
17974 swig_obj[0] = args;
17975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17978 }
17979 arg1 = reinterpret_cast< wxGrid * >(argp1);
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj = 0;
17995 wxGrid *arg1 = (wxGrid *) 0 ;
17996 wxColour *arg2 = 0 ;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 wxColour temp2 ;
18000 PyObject * obj0 = 0 ;
18001 PyObject * obj1 = 0 ;
18002 char * kwnames[] = {
18003 (char *) "self",(char *) "c", NULL
18004 };
18005
18006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18008 if (!SWIG_IsOK(res1)) {
18009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18010 }
18011 arg1 = reinterpret_cast< wxGrid * >(argp1);
18012 {
18013 arg2 = &temp2;
18014 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18015 }
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 resultobj = SWIG_Py_Void();
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj = 0;
18031 wxGrid *arg1 = (wxGrid *) 0 ;
18032 wxColour *arg2 = 0 ;
18033 void *argp1 = 0 ;
18034 int res1 = 0 ;
18035 wxColour temp2 ;
18036 PyObject * obj0 = 0 ;
18037 PyObject * obj1 = 0 ;
18038 char * kwnames[] = {
18039 (char *) "self",(char *) "c", NULL
18040 };
18041
18042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18044 if (!SWIG_IsOK(res1)) {
18045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18046 }
18047 arg1 = reinterpret_cast< wxGrid * >(argp1);
18048 {
18049 arg2 = &temp2;
18050 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18051 }
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 resultobj = SWIG_Py_Void();
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj = 0;
18067 wxGrid *arg1 = (wxGrid *) 0 ;
18068 wxString *arg2 = 0 ;
18069 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18070 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18071 void *argp1 = 0 ;
18072 int res1 = 0 ;
18073 bool temp2 = false ;
18074 void *argp3 = 0 ;
18075 int res3 = 0 ;
18076 void *argp4 = 0 ;
18077 int res4 = 0 ;
18078 PyObject * obj0 = 0 ;
18079 PyObject * obj1 = 0 ;
18080 PyObject * obj2 = 0 ;
18081 PyObject * obj3 = 0 ;
18082 char * kwnames[] = {
18083 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18084 };
18085
18086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18090 }
18091 arg1 = reinterpret_cast< wxGrid * >(argp1);
18092 {
18093 arg2 = wxString_in_helper(obj1);
18094 if (arg2 == NULL) SWIG_fail;
18095 temp2 = true;
18096 }
18097 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18098 if (!SWIG_IsOK(res3)) {
18099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18100 }
18101 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18102 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18103 if (!SWIG_IsOK(res4)) {
18104 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18105 }
18106 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18107 {
18108 PyThreadState* __tstate = wxPyBeginAllowThreads();
18109 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 resultobj = SWIG_Py_Void();
18114 {
18115 if (temp2)
18116 delete arg2;
18117 }
18118 return resultobj;
18119 fail:
18120 {
18121 if (temp2)
18122 delete arg2;
18123 }
18124 return NULL;
18125 }
18126
18127
18128 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj = 0;
18130 wxGrid *arg1 = (wxGrid *) 0 ;
18131 int arg2 ;
18132 int arg3 ;
18133 wxGridCellEditor *result = 0 ;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 int val2 ;
18137 int ecode2 = 0 ;
18138 int val3 ;
18139 int ecode3 = 0 ;
18140 PyObject * obj0 = 0 ;
18141 PyObject * obj1 = 0 ;
18142 PyObject * obj2 = 0 ;
18143 char * kwnames[] = {
18144 (char *) "self",(char *) "row",(char *) "col", NULL
18145 };
18146
18147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18149 if (!SWIG_IsOK(res1)) {
18150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18151 }
18152 arg1 = reinterpret_cast< wxGrid * >(argp1);
18153 ecode2 = SWIG_AsVal_int(obj1, &val2);
18154 if (!SWIG_IsOK(ecode2)) {
18155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18156 }
18157 arg2 = static_cast< int >(val2);
18158 ecode3 = SWIG_AsVal_int(obj2, &val3);
18159 if (!SWIG_IsOK(ecode3)) {
18160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18161 }
18162 arg3 = static_cast< int >(val3);
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 {
18170 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18171 }
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18179 PyObject *resultobj = 0;
18180 wxGrid *arg1 = (wxGrid *) 0 ;
18181 int arg2 ;
18182 int arg3 ;
18183 wxGridCellRenderer *result = 0 ;
18184 void *argp1 = 0 ;
18185 int res1 = 0 ;
18186 int val2 ;
18187 int ecode2 = 0 ;
18188 int val3 ;
18189 int ecode3 = 0 ;
18190 PyObject * obj0 = 0 ;
18191 PyObject * obj1 = 0 ;
18192 PyObject * obj2 = 0 ;
18193 char * kwnames[] = {
18194 (char *) "self",(char *) "row",(char *) "col", NULL
18195 };
18196
18197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18199 if (!SWIG_IsOK(res1)) {
18200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18201 }
18202 arg1 = reinterpret_cast< wxGrid * >(argp1);
18203 ecode2 = SWIG_AsVal_int(obj1, &val2);
18204 if (!SWIG_IsOK(ecode2)) {
18205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18206 }
18207 arg2 = static_cast< int >(val2);
18208 ecode3 = SWIG_AsVal_int(obj2, &val3);
18209 if (!SWIG_IsOK(ecode3)) {
18210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18211 }
18212 arg3 = static_cast< int >(val3);
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 {
18220 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18221 }
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj = 0;
18230 wxGrid *arg1 = (wxGrid *) 0 ;
18231 wxString *arg2 = 0 ;
18232 wxGridCellEditor *result = 0 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 bool temp2 = false ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "self",(char *) "typeName", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18246 }
18247 arg1 = reinterpret_cast< wxGrid * >(argp1);
18248 {
18249 arg2 = wxString_in_helper(obj1);
18250 if (arg2 == NULL) SWIG_fail;
18251 temp2 = true;
18252 }
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 {
18260 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18261 }
18262 {
18263 if (temp2)
18264 delete arg2;
18265 }
18266 return resultobj;
18267 fail:
18268 {
18269 if (temp2)
18270 delete arg2;
18271 }
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj = 0;
18278 wxGrid *arg1 = (wxGrid *) 0 ;
18279 wxString *arg2 = 0 ;
18280 wxGridCellRenderer *result = 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 bool temp2 = false ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 char * kwnames[] = {
18287 (char *) "self",(char *) "typeName", NULL
18288 };
18289
18290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18292 if (!SWIG_IsOK(res1)) {
18293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18294 }
18295 arg1 = reinterpret_cast< wxGrid * >(argp1);
18296 {
18297 arg2 = wxString_in_helper(obj1);
18298 if (arg2 == NULL) SWIG_fail;
18299 temp2 = true;
18300 }
18301 {
18302 PyThreadState* __tstate = wxPyBeginAllowThreads();
18303 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18304 wxPyEndAllowThreads(__tstate);
18305 if (PyErr_Occurred()) SWIG_fail;
18306 }
18307 {
18308 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18309 }
18310 {
18311 if (temp2)
18312 delete arg2;
18313 }
18314 return resultobj;
18315 fail:
18316 {
18317 if (temp2)
18318 delete arg2;
18319 }
18320 return NULL;
18321 }
18322
18323
18324 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj = 0;
18326 wxGrid *arg1 = (wxGrid *) 0 ;
18327 int arg2 ;
18328 int arg3 ;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 int val2 ;
18332 int ecode2 = 0 ;
18333 int val3 ;
18334 int ecode3 = 0 ;
18335 PyObject * obj0 = 0 ;
18336 PyObject * obj1 = 0 ;
18337 PyObject * obj2 = 0 ;
18338 char * kwnames[] = {
18339 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18340 };
18341
18342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18346 }
18347 arg1 = reinterpret_cast< wxGrid * >(argp1);
18348 ecode2 = SWIG_AsVal_int(obj1, &val2);
18349 if (!SWIG_IsOK(ecode2)) {
18350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18351 }
18352 arg2 = static_cast< int >(val2);
18353 ecode3 = SWIG_AsVal_int(obj2, &val3);
18354 if (!SWIG_IsOK(ecode3)) {
18355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18356 }
18357 arg3 = static_cast< int >(val3);
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 (arg1)->SetMargins(arg2,arg3);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = SWIG_Py_Void();
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18372 PyObject *resultobj = 0;
18373 wxGrid *arg1 = (wxGrid *) 0 ;
18374 wxWindow *result = 0 ;
18375 void *argp1 = 0 ;
18376 int res1 = 0 ;
18377 PyObject *swig_obj[1] ;
18378
18379 if (!args) SWIG_fail;
18380 swig_obj[0] = args;
18381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18382 if (!SWIG_IsOK(res1)) {
18383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18384 }
18385 arg1 = reinterpret_cast< wxGrid * >(argp1);
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 result = (wxWindow *)(arg1)->GetGridWindow();
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 {
18393 resultobj = wxPyMake_wxObject(result, 0);
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18402 PyObject *resultobj = 0;
18403 wxGrid *arg1 = (wxGrid *) 0 ;
18404 wxWindow *result = 0 ;
18405 void *argp1 = 0 ;
18406 int res1 = 0 ;
18407 PyObject *swig_obj[1] ;
18408
18409 if (!args) SWIG_fail;
18410 swig_obj[0] = args;
18411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18412 if (!SWIG_IsOK(res1)) {
18413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18414 }
18415 arg1 = reinterpret_cast< wxGrid * >(argp1);
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 {
18423 resultobj = wxPyMake_wxObject(result, 0);
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxGrid *arg1 = (wxGrid *) 0 ;
18434 wxWindow *result = 0 ;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18444 }
18445 arg1 = reinterpret_cast< wxGrid * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = wxPyMake_wxObject(result, 0);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18462 PyObject *resultobj = 0;
18463 wxGrid *arg1 = (wxGrid *) 0 ;
18464 wxWindow *result = 0 ;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 PyObject *swig_obj[1] ;
18468
18469 if (!args) SWIG_fail;
18470 swig_obj[0] = args;
18471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18474 }
18475 arg1 = reinterpret_cast< wxGrid * >(argp1);
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 {
18483 resultobj = wxPyMake_wxObject(result, 0);
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj = 0;
18493 wxGrid *arg1 = (wxGrid *) 0 ;
18494 int arg2 ;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 int val2 ;
18498 int ecode2 = 0 ;
18499 PyObject * obj0 = 0 ;
18500 PyObject * obj1 = 0 ;
18501 char * kwnames[] = {
18502 (char *) "self",(char *) "x", NULL
18503 };
18504
18505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18507 if (!SWIG_IsOK(res1)) {
18508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18509 }
18510 arg1 = reinterpret_cast< wxGrid * >(argp1);
18511 ecode2 = SWIG_AsVal_int(obj1, &val2);
18512 if (!SWIG_IsOK(ecode2)) {
18513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18514 }
18515 arg2 = static_cast< int >(val2);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 (arg1)->SetScrollLineX(arg2);
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 resultobj = SWIG_Py_Void();
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj = 0;
18531 wxGrid *arg1 = (wxGrid *) 0 ;
18532 int arg2 ;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 int val2 ;
18536 int ecode2 = 0 ;
18537 PyObject * obj0 = 0 ;
18538 PyObject * obj1 = 0 ;
18539 char * kwnames[] = {
18540 (char *) "self",(char *) "y", NULL
18541 };
18542
18543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18545 if (!SWIG_IsOK(res1)) {
18546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18547 }
18548 arg1 = reinterpret_cast< wxGrid * >(argp1);
18549 ecode2 = SWIG_AsVal_int(obj1, &val2);
18550 if (!SWIG_IsOK(ecode2)) {
18551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18552 }
18553 arg2 = static_cast< int >(val2);
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 (arg1)->SetScrollLineY(arg2);
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_Py_Void();
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxGrid *arg1 = (wxGrid *) 0 ;
18570 int result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18580 }
18581 arg1 = reinterpret_cast< wxGrid * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_From_int(static_cast< int >(result));
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxGrid *arg1 = (wxGrid *) 0 ;
18598 int result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18608 }
18609 arg1 = reinterpret_cast< wxGrid * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_From_int(static_cast< int >(result));
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = 0;
18625 wxGrid *arg1 = (wxGrid *) 0 ;
18626 int arg2 ;
18627 int result;
18628 void *argp1 = 0 ;
18629 int res1 = 0 ;
18630 int val2 ;
18631 int ecode2 = 0 ;
18632 PyObject * obj0 = 0 ;
18633 PyObject * obj1 = 0 ;
18634 char * kwnames[] = {
18635 (char *) "self",(char *) "x", NULL
18636 };
18637
18638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18640 if (!SWIG_IsOK(res1)) {
18641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18642 }
18643 arg1 = reinterpret_cast< wxGrid * >(argp1);
18644 ecode2 = SWIG_AsVal_int(obj1, &val2);
18645 if (!SWIG_IsOK(ecode2)) {
18646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18647 }
18648 arg2 = static_cast< int >(val2);
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 resultobj = SWIG_From_int(static_cast< int >(result));
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18663 PyObject *resultobj = 0;
18664 wxGrid *arg1 = (wxGrid *) 0 ;
18665 int arg2 ;
18666 int result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 int val2 ;
18670 int ecode2 = 0 ;
18671 PyObject * obj0 = 0 ;
18672 PyObject * obj1 = 0 ;
18673 char * kwnames[] = {
18674 (char *) "self",(char *) "y", NULL
18675 };
18676
18677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18679 if (!SWIG_IsOK(res1)) {
18680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18681 }
18682 arg1 = reinterpret_cast< wxGrid * >(argp1);
18683 ecode2 = SWIG_AsVal_int(obj1, &val2);
18684 if (!SWIG_IsOK(ecode2)) {
18685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18686 }
18687 arg2 = static_cast< int >(val2);
18688 {
18689 PyThreadState* __tstate = wxPyBeginAllowThreads();
18690 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 resultobj = SWIG_From_int(static_cast< int >(result));
18695 return resultobj;
18696 fail:
18697 return NULL;
18698 }
18699
18700
18701 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18702 PyObject *resultobj = 0;
18703 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18704 SwigValueWrapper<wxVisualAttributes > result;
18705 int val1 ;
18706 int ecode1 = 0 ;
18707 PyObject * obj0 = 0 ;
18708 char * kwnames[] = {
18709 (char *) "variant", NULL
18710 };
18711
18712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18713 if (obj0) {
18714 ecode1 = SWIG_AsVal_int(obj0, &val1);
18715 if (!SWIG_IsOK(ecode1)) {
18716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18717 }
18718 arg1 = static_cast< wxWindowVariant >(val1);
18719 }
18720 {
18721 if (!wxPyCheckForApp()) SWIG_fail;
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = wxGrid::GetClassDefaultAttributes(arg1);
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18735 PyObject *obj;
18736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18737 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18738 return SWIG_Py_Void();
18739 }
18740
18741 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18742 return SWIG_Python_InitShadowInstance(args);
18743 }
18744
18745 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj = 0;
18747 int arg1 ;
18748 wxEventType arg2 ;
18749 wxGrid *arg3 = (wxGrid *) 0 ;
18750 int arg4 = (int) -1 ;
18751 int arg5 = (int) -1 ;
18752 int arg6 = (int) -1 ;
18753 int arg7 = (int) -1 ;
18754 bool arg8 = (bool) true ;
18755 bool arg9 = (bool) false ;
18756 bool arg10 = (bool) false ;
18757 bool arg11 = (bool) false ;
18758 bool arg12 = (bool) false ;
18759 wxGridEvent *result = 0 ;
18760 int val1 ;
18761 int ecode1 = 0 ;
18762 int val2 ;
18763 int ecode2 = 0 ;
18764 void *argp3 = 0 ;
18765 int res3 = 0 ;
18766 int val4 ;
18767 int ecode4 = 0 ;
18768 int val5 ;
18769 int ecode5 = 0 ;
18770 int val6 ;
18771 int ecode6 = 0 ;
18772 int val7 ;
18773 int ecode7 = 0 ;
18774 bool val8 ;
18775 int ecode8 = 0 ;
18776 bool val9 ;
18777 int ecode9 = 0 ;
18778 bool val10 ;
18779 int ecode10 = 0 ;
18780 bool val11 ;
18781 int ecode11 = 0 ;
18782 bool val12 ;
18783 int ecode12 = 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 PyObject * obj2 = 0 ;
18787 PyObject * obj3 = 0 ;
18788 PyObject * obj4 = 0 ;
18789 PyObject * obj5 = 0 ;
18790 PyObject * obj6 = 0 ;
18791 PyObject * obj7 = 0 ;
18792 PyObject * obj8 = 0 ;
18793 PyObject * obj9 = 0 ;
18794 PyObject * obj10 = 0 ;
18795 PyObject * obj11 = 0 ;
18796 char * kwnames[] = {
18797 (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
18798 };
18799
18800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOOOO:new_GridEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
18801 ecode1 = SWIG_AsVal_int(obj0, &val1);
18802 if (!SWIG_IsOK(ecode1)) {
18803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18804 }
18805 arg1 = static_cast< int >(val1);
18806 ecode2 = SWIG_AsVal_int(obj1, &val2);
18807 if (!SWIG_IsOK(ecode2)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18809 }
18810 arg2 = static_cast< wxEventType >(val2);
18811 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18812 if (!SWIG_IsOK(res3)) {
18813 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18814 }
18815 arg3 = reinterpret_cast< wxGrid * >(argp3);
18816 if (obj3) {
18817 ecode4 = SWIG_AsVal_int(obj3, &val4);
18818 if (!SWIG_IsOK(ecode4)) {
18819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18820 }
18821 arg4 = static_cast< int >(val4);
18822 }
18823 if (obj4) {
18824 ecode5 = SWIG_AsVal_int(obj4, &val5);
18825 if (!SWIG_IsOK(ecode5)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18827 }
18828 arg5 = static_cast< int >(val5);
18829 }
18830 if (obj5) {
18831 ecode6 = SWIG_AsVal_int(obj5, &val6);
18832 if (!SWIG_IsOK(ecode6)) {
18833 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18834 }
18835 arg6 = static_cast< int >(val6);
18836 }
18837 if (obj6) {
18838 ecode7 = SWIG_AsVal_int(obj6, &val7);
18839 if (!SWIG_IsOK(ecode7)) {
18840 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18841 }
18842 arg7 = static_cast< int >(val7);
18843 }
18844 if (obj7) {
18845 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18846 if (!SWIG_IsOK(ecode8)) {
18847 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18848 }
18849 arg8 = static_cast< bool >(val8);
18850 }
18851 if (obj8) {
18852 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18853 if (!SWIG_IsOK(ecode9)) {
18854 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18855 }
18856 arg9 = static_cast< bool >(val9);
18857 }
18858 if (obj9) {
18859 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18860 if (!SWIG_IsOK(ecode10)) {
18861 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18862 }
18863 arg10 = static_cast< bool >(val10);
18864 }
18865 if (obj10) {
18866 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18867 if (!SWIG_IsOK(ecode11)) {
18868 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18869 }
18870 arg11 = static_cast< bool >(val11);
18871 }
18872 if (obj11) {
18873 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18874 if (!SWIG_IsOK(ecode12)) {
18875 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18876 }
18877 arg12 = static_cast< bool >(val12);
18878 }
18879 {
18880 PyThreadState* __tstate = wxPyBeginAllowThreads();
18881 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18882 wxPyEndAllowThreads(__tstate);
18883 if (PyErr_Occurred()) SWIG_fail;
18884 }
18885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18893 PyObject *resultobj = 0;
18894 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18895 int result;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 PyObject *swig_obj[1] ;
18899
18900 if (!args) SWIG_fail;
18901 swig_obj[0] = args;
18902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18903 if (!SWIG_IsOK(res1)) {
18904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18905 }
18906 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 result = (int)(arg1)->GetRow();
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_From_int(static_cast< int >(result));
18914 return resultobj;
18915 fail:
18916 return NULL;
18917 }
18918
18919
18920 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18921 PyObject *resultobj = 0;
18922 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18923 int result;
18924 void *argp1 = 0 ;
18925 int res1 = 0 ;
18926 PyObject *swig_obj[1] ;
18927
18928 if (!args) SWIG_fail;
18929 swig_obj[0] = args;
18930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18931 if (!SWIG_IsOK(res1)) {
18932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18933 }
18934 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 result = (int)(arg1)->GetCol();
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 resultobj = SWIG_From_int(static_cast< int >(result));
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18949 PyObject *resultobj = 0;
18950 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18951 wxPoint result;
18952 void *argp1 = 0 ;
18953 int res1 = 0 ;
18954 PyObject *swig_obj[1] ;
18955
18956 if (!args) SWIG_fail;
18957 swig_obj[0] = args;
18958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18959 if (!SWIG_IsOK(res1)) {
18960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18961 }
18962 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = (arg1)->GetPosition();
18966 wxPyEndAllowThreads(__tstate);
18967 if (PyErr_Occurred()) SWIG_fail;
18968 }
18969 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18977 PyObject *resultobj = 0;
18978 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18979 bool result;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 PyObject *swig_obj[1] ;
18983
18984 if (!args) SWIG_fail;
18985 swig_obj[0] = args;
18986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18987 if (!SWIG_IsOK(res1)) {
18988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18989 }
18990 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18991 {
18992 PyThreadState* __tstate = wxPyBeginAllowThreads();
18993 result = (bool)(arg1)->Selecting();
18994 wxPyEndAllowThreads(__tstate);
18995 if (PyErr_Occurred()) SWIG_fail;
18996 }
18997 {
18998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18999 }
19000 return resultobj;
19001 fail:
19002 return NULL;
19003 }
19004
19005
19006 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19007 PyObject *resultobj = 0;
19008 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19009 bool result;
19010 void *argp1 = 0 ;
19011 int res1 = 0 ;
19012 PyObject *swig_obj[1] ;
19013
19014 if (!args) SWIG_fail;
19015 swig_obj[0] = args;
19016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19017 if (!SWIG_IsOK(res1)) {
19018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19019 }
19020 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 result = (bool)(arg1)->ControlDown();
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 {
19028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19029 }
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19037 PyObject *resultobj = 0;
19038 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19039 bool result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 PyObject *swig_obj[1] ;
19043
19044 if (!args) SWIG_fail;
19045 swig_obj[0] = args;
19046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19049 }
19050 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 result = (bool)(arg1)->MetaDown();
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 {
19058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19059 }
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19067 PyObject *resultobj = 0;
19068 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19069 bool result;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 PyObject *swig_obj[1] ;
19073
19074 if (!args) SWIG_fail;
19075 swig_obj[0] = args;
19076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19077 if (!SWIG_IsOK(res1)) {
19078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19079 }
19080 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 result = (bool)(arg1)->ShiftDown();
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 {
19088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089 }
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19097 PyObject *resultobj = 0;
19098 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19099 bool result;
19100 void *argp1 = 0 ;
19101 int res1 = 0 ;
19102 PyObject *swig_obj[1] ;
19103
19104 if (!args) SWIG_fail;
19105 swig_obj[0] = args;
19106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19107 if (!SWIG_IsOK(res1)) {
19108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19109 }
19110 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (bool)(arg1)->AltDown();
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *obj;
19128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19129 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19130 return SWIG_Py_Void();
19131 }
19132
19133 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19134 return SWIG_Python_InitShadowInstance(args);
19135 }
19136
19137 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19138 PyObject *resultobj = 0;
19139 int arg1 ;
19140 wxEventType arg2 ;
19141 wxGrid *arg3 = (wxGrid *) 0 ;
19142 int arg4 = (int) -1 ;
19143 int arg5 = (int) -1 ;
19144 int arg6 = (int) -1 ;
19145 bool arg7 = (bool) false ;
19146 bool arg8 = (bool) false ;
19147 bool arg9 = (bool) false ;
19148 bool arg10 = (bool) false ;
19149 wxGridSizeEvent *result = 0 ;
19150 int val1 ;
19151 int ecode1 = 0 ;
19152 int val2 ;
19153 int ecode2 = 0 ;
19154 void *argp3 = 0 ;
19155 int res3 = 0 ;
19156 int val4 ;
19157 int ecode4 = 0 ;
19158 int val5 ;
19159 int ecode5 = 0 ;
19160 int val6 ;
19161 int ecode6 = 0 ;
19162 bool val7 ;
19163 int ecode7 = 0 ;
19164 bool val8 ;
19165 int ecode8 = 0 ;
19166 bool val9 ;
19167 int ecode9 = 0 ;
19168 bool val10 ;
19169 int ecode10 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 PyObject * obj2 = 0 ;
19173 PyObject * obj3 = 0 ;
19174 PyObject * obj4 = 0 ;
19175 PyObject * obj5 = 0 ;
19176 PyObject * obj6 = 0 ;
19177 PyObject * obj7 = 0 ;
19178 PyObject * obj8 = 0 ;
19179 PyObject * obj9 = 0 ;
19180 char * kwnames[] = {
19181 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19182 };
19183
19184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19185 ecode1 = SWIG_AsVal_int(obj0, &val1);
19186 if (!SWIG_IsOK(ecode1)) {
19187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19188 }
19189 arg1 = static_cast< int >(val1);
19190 ecode2 = SWIG_AsVal_int(obj1, &val2);
19191 if (!SWIG_IsOK(ecode2)) {
19192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19193 }
19194 arg2 = static_cast< wxEventType >(val2);
19195 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19196 if (!SWIG_IsOK(res3)) {
19197 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19198 }
19199 arg3 = reinterpret_cast< wxGrid * >(argp3);
19200 if (obj3) {
19201 ecode4 = SWIG_AsVal_int(obj3, &val4);
19202 if (!SWIG_IsOK(ecode4)) {
19203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19204 }
19205 arg4 = static_cast< int >(val4);
19206 }
19207 if (obj4) {
19208 ecode5 = SWIG_AsVal_int(obj4, &val5);
19209 if (!SWIG_IsOK(ecode5)) {
19210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19211 }
19212 arg5 = static_cast< int >(val5);
19213 }
19214 if (obj5) {
19215 ecode6 = SWIG_AsVal_int(obj5, &val6);
19216 if (!SWIG_IsOK(ecode6)) {
19217 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19218 }
19219 arg6 = static_cast< int >(val6);
19220 }
19221 if (obj6) {
19222 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19223 if (!SWIG_IsOK(ecode7)) {
19224 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19225 }
19226 arg7 = static_cast< bool >(val7);
19227 }
19228 if (obj7) {
19229 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19230 if (!SWIG_IsOK(ecode8)) {
19231 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19232 }
19233 arg8 = static_cast< bool >(val8);
19234 }
19235 if (obj8) {
19236 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19237 if (!SWIG_IsOK(ecode9)) {
19238 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19239 }
19240 arg9 = static_cast< bool >(val9);
19241 }
19242 if (obj9) {
19243 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19244 if (!SWIG_IsOK(ecode10)) {
19245 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19246 }
19247 arg10 = static_cast< bool >(val10);
19248 }
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19256 return resultobj;
19257 fail:
19258 return NULL;
19259 }
19260
19261
19262 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19263 PyObject *resultobj = 0;
19264 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19265 int result;
19266 void *argp1 = 0 ;
19267 int res1 = 0 ;
19268 PyObject *swig_obj[1] ;
19269
19270 if (!args) SWIG_fail;
19271 swig_obj[0] = args;
19272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19275 }
19276 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19277 {
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 result = (int)(arg1)->GetRowOrCol();
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_From_int(static_cast< int >(result));
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19293 wxPoint result;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 PyObject *swig_obj[1] ;
19297
19298 if (!args) SWIG_fail;
19299 swig_obj[0] = args;
19300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19303 }
19304 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 result = (arg1)->GetPosition();
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19319 PyObject *resultobj = 0;
19320 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19321 bool result;
19322 void *argp1 = 0 ;
19323 int res1 = 0 ;
19324 PyObject *swig_obj[1] ;
19325
19326 if (!args) SWIG_fail;
19327 swig_obj[0] = args;
19328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19331 }
19332 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (bool)(arg1)->ControlDown();
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19341 }
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19349 PyObject *resultobj = 0;
19350 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19351 bool result;
19352 void *argp1 = 0 ;
19353 int res1 = 0 ;
19354 PyObject *swig_obj[1] ;
19355
19356 if (!args) SWIG_fail;
19357 swig_obj[0] = args;
19358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19359 if (!SWIG_IsOK(res1)) {
19360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19361 }
19362 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 result = (bool)(arg1)->MetaDown();
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 {
19370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19381 bool result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19391 }
19392 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (bool)(arg1)->ShiftDown();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 {
19400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19409 PyObject *resultobj = 0;
19410 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19411 bool result;
19412 void *argp1 = 0 ;
19413 int res1 = 0 ;
19414 PyObject *swig_obj[1] ;
19415
19416 if (!args) SWIG_fail;
19417 swig_obj[0] = args;
19418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19421 }
19422 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19423 {
19424 PyThreadState* __tstate = wxPyBeginAllowThreads();
19425 result = (bool)(arg1)->AltDown();
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 {
19430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19431 }
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19439 PyObject *obj;
19440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19441 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19442 return SWIG_Py_Void();
19443 }
19444
19445 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19446 return SWIG_Python_InitShadowInstance(args);
19447 }
19448
19449 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj = 0;
19451 int arg1 ;
19452 wxEventType arg2 ;
19453 wxGrid *arg3 = (wxGrid *) 0 ;
19454 wxGridCellCoords *arg4 = 0 ;
19455 wxGridCellCoords *arg5 = 0 ;
19456 bool arg6 = (bool) true ;
19457 bool arg7 = (bool) false ;
19458 bool arg8 = (bool) false ;
19459 bool arg9 = (bool) false ;
19460 bool arg10 = (bool) false ;
19461 wxGridRangeSelectEvent *result = 0 ;
19462 int val1 ;
19463 int ecode1 = 0 ;
19464 int val2 ;
19465 int ecode2 = 0 ;
19466 void *argp3 = 0 ;
19467 int res3 = 0 ;
19468 wxGridCellCoords temp4 ;
19469 wxGridCellCoords temp5 ;
19470 bool val6 ;
19471 int ecode6 = 0 ;
19472 bool val7 ;
19473 int ecode7 = 0 ;
19474 bool val8 ;
19475 int ecode8 = 0 ;
19476 bool val9 ;
19477 int ecode9 = 0 ;
19478 bool val10 ;
19479 int ecode10 = 0 ;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 PyObject * obj2 = 0 ;
19483 PyObject * obj3 = 0 ;
19484 PyObject * obj4 = 0 ;
19485 PyObject * obj5 = 0 ;
19486 PyObject * obj6 = 0 ;
19487 PyObject * obj7 = 0 ;
19488 PyObject * obj8 = 0 ;
19489 PyObject * obj9 = 0 ;
19490 char * kwnames[] = {
19491 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19492 };
19493
19494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19495 ecode1 = SWIG_AsVal_int(obj0, &val1);
19496 if (!SWIG_IsOK(ecode1)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19498 }
19499 arg1 = static_cast< int >(val1);
19500 ecode2 = SWIG_AsVal_int(obj1, &val2);
19501 if (!SWIG_IsOK(ecode2)) {
19502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19503 }
19504 arg2 = static_cast< wxEventType >(val2);
19505 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19506 if (!SWIG_IsOK(res3)) {
19507 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19508 }
19509 arg3 = reinterpret_cast< wxGrid * >(argp3);
19510 {
19511 arg4 = &temp4;
19512 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19513 }
19514 {
19515 arg5 = &temp5;
19516 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19517 }
19518 if (obj5) {
19519 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19520 if (!SWIG_IsOK(ecode6)) {
19521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19522 }
19523 arg6 = static_cast< bool >(val6);
19524 }
19525 if (obj6) {
19526 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19527 if (!SWIG_IsOK(ecode7)) {
19528 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19529 }
19530 arg7 = static_cast< bool >(val7);
19531 }
19532 if (obj7) {
19533 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19534 if (!SWIG_IsOK(ecode8)) {
19535 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19536 }
19537 arg8 = static_cast< bool >(val8);
19538 }
19539 if (obj8) {
19540 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19541 if (!SWIG_IsOK(ecode9)) {
19542 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19543 }
19544 arg9 = static_cast< bool >(val9);
19545 }
19546 if (obj9) {
19547 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19548 if (!SWIG_IsOK(ecode10)) {
19549 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19550 }
19551 arg10 = static_cast< bool >(val10);
19552 }
19553 {
19554 PyThreadState* __tstate = wxPyBeginAllowThreads();
19555 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19567 PyObject *resultobj = 0;
19568 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19569 wxGridCellCoords result;
19570 void *argp1 = 0 ;
19571 int res1 = 0 ;
19572 PyObject *swig_obj[1] ;
19573
19574 if (!args) SWIG_fail;
19575 swig_obj[0] = args;
19576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19577 if (!SWIG_IsOK(res1)) {
19578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19579 }
19580 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = (arg1)->GetTopLeftCoords();
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 PyObject *resultobj = 0;
19596 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19597 wxGridCellCoords result;
19598 void *argp1 = 0 ;
19599 int res1 = 0 ;
19600 PyObject *swig_obj[1] ;
19601
19602 if (!args) SWIG_fail;
19603 swig_obj[0] = args;
19604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19605 if (!SWIG_IsOK(res1)) {
19606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19607 }
19608 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 result = (arg1)->GetBottomRightCoords();
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 PyObject *resultobj = 0;
19624 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19625 int result;
19626 void *argp1 = 0 ;
19627 int res1 = 0 ;
19628 PyObject *swig_obj[1] ;
19629
19630 if (!args) SWIG_fail;
19631 swig_obj[0] = args;
19632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = (int)(arg1)->GetTopRow();
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 resultobj = SWIG_From_int(static_cast< int >(result));
19644 return resultobj;
19645 fail:
19646 return NULL;
19647 }
19648
19649
19650 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19651 PyObject *resultobj = 0;
19652 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19653 int result;
19654 void *argp1 = 0 ;
19655 int res1 = 0 ;
19656 PyObject *swig_obj[1] ;
19657
19658 if (!args) SWIG_fail;
19659 swig_obj[0] = args;
19660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19661 if (!SWIG_IsOK(res1)) {
19662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19663 }
19664 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19665 {
19666 PyThreadState* __tstate = wxPyBeginAllowThreads();
19667 result = (int)(arg1)->GetBottomRow();
19668 wxPyEndAllowThreads(__tstate);
19669 if (PyErr_Occurred()) SWIG_fail;
19670 }
19671 resultobj = SWIG_From_int(static_cast< int >(result));
19672 return resultobj;
19673 fail:
19674 return NULL;
19675 }
19676
19677
19678 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19679 PyObject *resultobj = 0;
19680 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19681 int result;
19682 void *argp1 = 0 ;
19683 int res1 = 0 ;
19684 PyObject *swig_obj[1] ;
19685
19686 if (!args) SWIG_fail;
19687 swig_obj[0] = args;
19688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19689 if (!SWIG_IsOK(res1)) {
19690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19691 }
19692 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19693 {
19694 PyThreadState* __tstate = wxPyBeginAllowThreads();
19695 result = (int)(arg1)->GetLeftCol();
19696 wxPyEndAllowThreads(__tstate);
19697 if (PyErr_Occurred()) SWIG_fail;
19698 }
19699 resultobj = SWIG_From_int(static_cast< int >(result));
19700 return resultobj;
19701 fail:
19702 return NULL;
19703 }
19704
19705
19706 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19707 PyObject *resultobj = 0;
19708 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19709 int result;
19710 void *argp1 = 0 ;
19711 int res1 = 0 ;
19712 PyObject *swig_obj[1] ;
19713
19714 if (!args) SWIG_fail;
19715 swig_obj[0] = args;
19716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19717 if (!SWIG_IsOK(res1)) {
19718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19719 }
19720 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19721 {
19722 PyThreadState* __tstate = wxPyBeginAllowThreads();
19723 result = (int)(arg1)->GetRightCol();
19724 wxPyEndAllowThreads(__tstate);
19725 if (PyErr_Occurred()) SWIG_fail;
19726 }
19727 resultobj = SWIG_From_int(static_cast< int >(result));
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 PyObject *resultobj = 0;
19736 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19737 bool result;
19738 void *argp1 = 0 ;
19739 int res1 = 0 ;
19740 PyObject *swig_obj[1] ;
19741
19742 if (!args) SWIG_fail;
19743 swig_obj[0] = args;
19744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19745 if (!SWIG_IsOK(res1)) {
19746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19747 }
19748 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (bool)(arg1)->Selecting();
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 {
19756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19757 }
19758 return resultobj;
19759 fail:
19760 return NULL;
19761 }
19762
19763
19764 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19765 PyObject *resultobj = 0;
19766 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19767 bool result;
19768 void *argp1 = 0 ;
19769 int res1 = 0 ;
19770 PyObject *swig_obj[1] ;
19771
19772 if (!args) SWIG_fail;
19773 swig_obj[0] = args;
19774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19775 if (!SWIG_IsOK(res1)) {
19776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19777 }
19778 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 result = (bool)(arg1)->ControlDown();
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 {
19786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19787 }
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 PyObject *resultobj = 0;
19796 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19797 bool result;
19798 void *argp1 = 0 ;
19799 int res1 = 0 ;
19800 PyObject *swig_obj[1] ;
19801
19802 if (!args) SWIG_fail;
19803 swig_obj[0] = args;
19804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19805 if (!SWIG_IsOK(res1)) {
19806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19807 }
19808 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (bool)(arg1)->MetaDown();
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 {
19816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19817 }
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19825 PyObject *resultobj = 0;
19826 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19827 bool result;
19828 void *argp1 = 0 ;
19829 int res1 = 0 ;
19830 PyObject *swig_obj[1] ;
19831
19832 if (!args) SWIG_fail;
19833 swig_obj[0] = args;
19834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19835 if (!SWIG_IsOK(res1)) {
19836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19837 }
19838 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (bool)(arg1)->ShiftDown();
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 {
19846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19847 }
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19855 PyObject *resultobj = 0;
19856 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19857 bool result;
19858 void *argp1 = 0 ;
19859 int res1 = 0 ;
19860 PyObject *swig_obj[1] ;
19861
19862 if (!args) SWIG_fail;
19863 swig_obj[0] = args;
19864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19867 }
19868 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (bool)(arg1)->AltDown();
19872 wxPyEndAllowThreads(__tstate);
19873 if (PyErr_Occurred()) SWIG_fail;
19874 }
19875 {
19876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19877 }
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 PyObject *obj;
19886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19887 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19888 return SWIG_Py_Void();
19889 }
19890
19891 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19892 return SWIG_Python_InitShadowInstance(args);
19893 }
19894
19895 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19896 PyObject *resultobj = 0;
19897 int arg1 ;
19898 wxEventType arg2 ;
19899 wxObject *arg3 = (wxObject *) 0 ;
19900 int arg4 ;
19901 int arg5 ;
19902 wxControl *arg6 = (wxControl *) 0 ;
19903 wxGridEditorCreatedEvent *result = 0 ;
19904 int val1 ;
19905 int ecode1 = 0 ;
19906 int val2 ;
19907 int ecode2 = 0 ;
19908 void *argp3 = 0 ;
19909 int res3 = 0 ;
19910 int val4 ;
19911 int ecode4 = 0 ;
19912 int val5 ;
19913 int ecode5 = 0 ;
19914 void *argp6 = 0 ;
19915 int res6 = 0 ;
19916 PyObject * obj0 = 0 ;
19917 PyObject * obj1 = 0 ;
19918 PyObject * obj2 = 0 ;
19919 PyObject * obj3 = 0 ;
19920 PyObject * obj4 = 0 ;
19921 PyObject * obj5 = 0 ;
19922 char * kwnames[] = {
19923 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
19924 };
19925
19926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19927 ecode1 = SWIG_AsVal_int(obj0, &val1);
19928 if (!SWIG_IsOK(ecode1)) {
19929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
19930 }
19931 arg1 = static_cast< int >(val1);
19932 ecode2 = SWIG_AsVal_int(obj1, &val2);
19933 if (!SWIG_IsOK(ecode2)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19935 }
19936 arg2 = static_cast< wxEventType >(val2);
19937 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
19938 if (!SWIG_IsOK(res3)) {
19939 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
19940 }
19941 arg3 = reinterpret_cast< wxObject * >(argp3);
19942 ecode4 = SWIG_AsVal_int(obj3, &val4);
19943 if (!SWIG_IsOK(ecode4)) {
19944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
19945 }
19946 arg4 = static_cast< int >(val4);
19947 ecode5 = SWIG_AsVal_int(obj4, &val5);
19948 if (!SWIG_IsOK(ecode5)) {
19949 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
19950 }
19951 arg5 = static_cast< int >(val5);
19952 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
19953 if (!SWIG_IsOK(res6)) {
19954 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
19955 }
19956 arg6 = reinterpret_cast< wxControl * >(argp6);
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
19960 wxPyEndAllowThreads(__tstate);
19961 if (PyErr_Occurred()) SWIG_fail;
19962 }
19963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19971 PyObject *resultobj = 0;
19972 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19973 int result;
19974 void *argp1 = 0 ;
19975 int res1 = 0 ;
19976 PyObject *swig_obj[1] ;
19977
19978 if (!args) SWIG_fail;
19979 swig_obj[0] = args;
19980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19981 if (!SWIG_IsOK(res1)) {
19982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19983 }
19984 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (int)(arg1)->GetRow();
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_From_int(static_cast< int >(result));
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19999 PyObject *resultobj = 0;
20000 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20001 int result;
20002 void *argp1 = 0 ;
20003 int res1 = 0 ;
20004 PyObject *swig_obj[1] ;
20005
20006 if (!args) SWIG_fail;
20007 swig_obj[0] = args;
20008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20009 if (!SWIG_IsOK(res1)) {
20010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20011 }
20012 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 result = (int)(arg1)->GetCol();
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 resultobj = SWIG_From_int(static_cast< int >(result));
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20027 PyObject *resultobj = 0;
20028 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20029 wxControl *result = 0 ;
20030 void *argp1 = 0 ;
20031 int res1 = 0 ;
20032 PyObject *swig_obj[1] ;
20033
20034 if (!args) SWIG_fail;
20035 swig_obj[0] = args;
20036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20039 }
20040 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 result = (wxControl *)(arg1)->GetControl();
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = wxPyMake_wxObject(result, 0);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj = 0;
20058 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20059 int arg2 ;
20060 void *argp1 = 0 ;
20061 int res1 = 0 ;
20062 int val2 ;
20063 int ecode2 = 0 ;
20064 PyObject * obj0 = 0 ;
20065 PyObject * obj1 = 0 ;
20066 char * kwnames[] = {
20067 (char *) "self",(char *) "row", NULL
20068 };
20069
20070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20072 if (!SWIG_IsOK(res1)) {
20073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20074 }
20075 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20076 ecode2 = SWIG_AsVal_int(obj1, &val2);
20077 if (!SWIG_IsOK(ecode2)) {
20078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20079 }
20080 arg2 = static_cast< int >(val2);
20081 {
20082 PyThreadState* __tstate = wxPyBeginAllowThreads();
20083 (arg1)->SetRow(arg2);
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 resultobj = SWIG_Py_Void();
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj = 0;
20096 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20097 int arg2 ;
20098 void *argp1 = 0 ;
20099 int res1 = 0 ;
20100 int val2 ;
20101 int ecode2 = 0 ;
20102 PyObject * obj0 = 0 ;
20103 PyObject * obj1 = 0 ;
20104 char * kwnames[] = {
20105 (char *) "self",(char *) "col", NULL
20106 };
20107
20108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20110 if (!SWIG_IsOK(res1)) {
20111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20112 }
20113 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20114 ecode2 = SWIG_AsVal_int(obj1, &val2);
20115 if (!SWIG_IsOK(ecode2)) {
20116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20117 }
20118 arg2 = static_cast< int >(val2);
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 (arg1)->SetCol(arg2);
20122 wxPyEndAllowThreads(__tstate);
20123 if (PyErr_Occurred()) SWIG_fail;
20124 }
20125 resultobj = SWIG_Py_Void();
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj = 0;
20134 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20135 wxControl *arg2 = (wxControl *) 0 ;
20136 void *argp1 = 0 ;
20137 int res1 = 0 ;
20138 void *argp2 = 0 ;
20139 int res2 = 0 ;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 char * kwnames[] = {
20143 (char *) "self",(char *) "ctrl", NULL
20144 };
20145
20146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20148 if (!SWIG_IsOK(res1)) {
20149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20150 }
20151 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20153 if (!SWIG_IsOK(res2)) {
20154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20155 }
20156 arg2 = reinterpret_cast< wxControl * >(argp2);
20157 {
20158 PyThreadState* __tstate = wxPyBeginAllowThreads();
20159 (arg1)->SetControl(arg2);
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 resultobj = SWIG_Py_Void();
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20171 PyObject *obj;
20172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20173 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20174 return SWIG_Py_Void();
20175 }
20176
20177 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20178 return SWIG_Python_InitShadowInstance(args);
20179 }
20180
20181 static PyMethodDef SwigMethods[] = {
20182 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20183 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20184 { (char *)"GridCellRenderer_IncRef", (PyCFunction)_wrap_GridCellRenderer_IncRef, METH_O, NULL},
20185 { (char *)"GridCellRenderer_DecRef", (PyCFunction)_wrap_GridCellRenderer_DecRef, METH_O, NULL},
20186 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20187 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20188 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20189 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20190 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20191 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20192 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20193 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20194 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20195 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20196 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20197 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20198 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20199 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20200 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20201 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20202 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20203 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20204 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20205 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20206 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20207 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20208 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20209 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20210 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20211 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20212 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20213 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20214 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20215 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20216 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20217 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20218 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20219 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20220 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20221 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20222 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20223 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20224 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20225 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20226 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20227 { (char *)"GridCellEditor_IncRef", (PyCFunction)_wrap_GridCellEditor_IncRef, METH_O, NULL},
20228 { (char *)"GridCellEditor_DecRef", (PyCFunction)_wrap_GridCellEditor_DecRef, METH_O, NULL},
20229 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20230 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20231 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20232 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20233 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20234 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20235 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20236 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20237 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20238 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20239 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20240 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20241 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20242 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20243 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20244 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20245 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20246 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20247 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20248 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20249 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20250 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20251 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20252 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20253 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20254 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20255 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20256 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20257 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20258 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20259 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20260 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20261 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20262 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20263 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20264 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20265 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20266 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20267 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20268 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20269 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20270 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20271 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20272 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20273 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20274 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20275 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20276 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20277 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20278 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20279 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20280 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20281 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20282 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20283 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20284 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20285 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20286 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20287 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20288 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20289 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20290 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20291 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20292 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20293 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20294 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20295 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20296 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20297 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20298 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20299 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20300 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20301 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20302 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20303 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20304 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20305 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20306 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20307 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20308 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20309 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20310 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20313 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20314 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20315 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20316 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20317 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20318 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20319 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20320 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20321 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20322 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20323 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20324 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20325 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20326 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20327 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20328 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20329 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20330 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20331 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20332 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20333 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20334 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20335 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20336 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20337 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20338 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20339 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20340 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20341 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20342 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20343 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20344 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20345 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20346 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20347 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20348 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20349 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20350 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20351 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20353 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20355 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20358 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20363 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20364 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20365 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20366 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20367 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20368 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20369 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20370 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20371 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20373 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20374 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20375 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20376 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20377 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20379 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20381 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20382 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20383 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20384 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20385 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20386 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20388 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20393 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20394 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20395 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20397 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20401 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20402 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20403 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20404 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20405 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20406 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20407 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20408 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20409 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20417 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20418 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20419 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20420 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20421 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20424 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20425 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20426 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20427 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20428 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20429 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20430 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20431 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20438 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20439 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20440 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20441 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20442 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20443 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20447 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20448 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20452 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20453 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20454 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20455 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20456 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20457 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20458 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20459 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20460 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20461 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20462 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20465 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20466 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20467 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20468 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20473 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20484 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20485 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20487 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20488 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20490 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20491 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20493 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20494 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20503 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20504 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20505 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20507 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20509 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20511 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20513 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20515 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20517 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20528 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20535 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20536 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20550 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20554 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20563 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20564 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20565 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20567 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20568 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20569 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20570 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20571 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20576 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20577 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20586 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20587 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20588 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20589 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20592 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20593 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20597 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20598 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20600 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20601 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20602 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20603 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20604 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20605 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20606 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20607 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20608 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20609 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20611 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20612 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20613 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20614 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20615 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20616 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20617 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20618 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20620 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20621 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20622 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20623 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20624 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20625 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20626 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20627 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20628 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20629 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20630 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20631 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20632 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20634 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20635 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20636 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20640 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20641 { NULL, NULL, 0, NULL }
20642 };
20643
20644
20645 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20646
20647 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20648 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20649 }
20650 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20651 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20652 }
20653 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20654 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20655 }
20656 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20657 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20658 }
20659 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20660 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20661 }
20662 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20663 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20664 }
20665 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20666 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20667 }
20668 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20669 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20670 }
20671 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20672 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20673 }
20674 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20675 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20676 }
20677 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20678 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20679 }
20680 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20681 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20682 }
20683 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20684 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20685 }
20686 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20687 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20688 }
20689 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20690 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20691 }
20692 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20693 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20694 }
20695 static void *_p_wxGridTo_p_wxPanel(void *x) {
20696 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20697 }
20698 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20699 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20700 }
20701 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20702 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20703 }
20704 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20705 return (void *)((wxPanel *) ((wxPyPanel *) x));
20706 }
20707 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20708 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20709 }
20710 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20711 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20712 }
20713 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20714 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20715 }
20716 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20717 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20718 }
20719 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20720 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20721 }
20722 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20723 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20724 }
20725 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20726 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20727 }
20728 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20729 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20730 }
20731 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20732 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20733 }
20734 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20735 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20736 }
20737 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20738 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20739 }
20740 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20741 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20742 }
20743 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20744 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20745 }
20746 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20747 return (void *)((wxWindow *) ((wxMenuBar *) x));
20748 }
20749 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20750 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20751 }
20752 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20753 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20754 }
20755 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20756 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20757 }
20758 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20759 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20760 }
20761 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20762 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20763 }
20764 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20765 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20766 }
20767 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20768 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20769 }
20770 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20771 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20772 }
20773 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20774 return (void *)((wxWindow *) ((wxPanel *) x));
20775 }
20776 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20777 return (void *)((wxWindow *) ((wxStatusBar *) x));
20778 }
20779 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20780 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20781 }
20782 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20783 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
20784 }
20785 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20786 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20787 }
20788 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20789 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20790 }
20791 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20792 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20793 }
20794 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20795 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20796 }
20797 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20798 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20799 }
20800 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20801 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20802 }
20803 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20804 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20805 }
20806 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20807 return (void *)((wxWindow *) ((wxSashWindow *) x));
20808 }
20809 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20810 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20811 }
20812 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20813 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20814 }
20815 static void *_p_wxControlTo_p_wxWindow(void *x) {
20816 return (void *)((wxWindow *) ((wxControl *) x));
20817 }
20818 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20819 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20820 }
20821 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20822 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20823 }
20824 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20825 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20826 }
20827 static void *_p_wxGridTo_p_wxWindow(void *x) {
20828 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20829 }
20830 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20831 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20832 }
20833 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20834 return (void *)((wxWindow *) ((wxPyWindow *) x));
20835 }
20836 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20837 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20838 }
20839 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20840 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20841 }
20842 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20843 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20844 }
20845 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20846 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20847 }
20848 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20849 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20850 }
20851 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20852 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20853 }
20854 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20855 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20856 }
20857 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20858 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20859 }
20860 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
20861 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
20862 }
20863 static void *_p_wxDialogTo_p_wxWindow(void *x) {
20864 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
20865 }
20866 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
20867 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
20868 }
20869 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
20870 return (void *)((wxControl *) ((wxControlWithItems *) x));
20871 }
20872 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
20873 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
20874 }
20875 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
20876 return (void *)((wxEvent *) ((wxMenuEvent *) x));
20877 }
20878 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
20879 return (void *)((wxEvent *) ((wxCloseEvent *) x));
20880 }
20881 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
20882 return (void *)((wxEvent *) ((wxMouseEvent *) x));
20883 }
20884 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
20885 return (void *)((wxEvent *) ((wxEraseEvent *) x));
20886 }
20887 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
20888 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
20889 }
20890 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
20891 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
20892 }
20893 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
20894 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
20895 }
20896 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
20897 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
20898 }
20899 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
20900 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
20901 }
20902 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
20903 return (void *)((wxEvent *) ((wxPyEvent *) x));
20904 }
20905 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
20906 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
20907 }
20908 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
20909 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
20910 }
20911 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
20912 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20913 }
20914 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
20915 return (void *)((wxEvent *) ((wxIdleEvent *) x));
20916 }
20917 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
20918 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
20919 }
20920 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
20921 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
20922 }
20923 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
20924 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
20925 }
20926 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
20927 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
20928 }
20929 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
20930 return (void *)((wxEvent *) ((wxActivateEvent *) x));
20931 }
20932 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
20933 return (void *)((wxEvent *) ((wxSizeEvent *) x));
20934 }
20935 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
20936 return (void *)((wxEvent *) ((wxMoveEvent *) x));
20937 }
20938 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
20939 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
20940 }
20941 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
20942 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
20943 }
20944 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
20945 return (void *)((wxEvent *) ((wxPaintEvent *) x));
20946 }
20947 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
20948 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
20949 }
20950 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
20951 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
20952 }
20953 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
20954 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
20955 }
20956 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
20957 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
20958 }
20959 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
20960 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20961 }
20962 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
20963 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
20964 }
20965 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
20966 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
20967 }
20968 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
20969 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
20970 }
20971 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
20972 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
20973 }
20974 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
20975 return (void *)((wxEvent *) ((wxFocusEvent *) x));
20976 }
20977 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
20978 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
20979 }
20980 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
20981 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
20982 }
20983 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
20984 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20985 }
20986 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
20987 return (void *)((wxEvent *) ((wxShowEvent *) x));
20988 }
20989 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
20990 return (void *)((wxEvent *) ((wxCommandEvent *) x));
20991 }
20992 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
20993 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
20994 }
20995 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
20996 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
20997 }
20998 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
20999 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21000 }
21001 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21002 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21003 }
21004 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21005 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21006 }
21007 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21008 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21009 }
21010 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21011 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21012 }
21013 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21014 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21015 }
21016 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21017 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21018 }
21019 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21020 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21021 }
21022 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21023 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21024 }
21025 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21026 return (void *)((wxObject *) ((wxSizerItem *) x));
21027 }
21028 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21029 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21030 }
21031 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21032 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21033 }
21034 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21035 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21036 }
21037 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21038 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21039 }
21040 static void *_p_wxSizerTo_p_wxObject(void *x) {
21041 return (void *)((wxObject *) ((wxSizer *) x));
21042 }
21043 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21044 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21045 }
21046 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21048 }
21049 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21050 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21051 }
21052 static void *_p_wxEventTo_p_wxObject(void *x) {
21053 return (void *)((wxObject *) ((wxEvent *) x));
21054 }
21055 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21056 return (void *)((wxObject *) ((wxFontData *) x));
21057 }
21058 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21059 return (void *)((wxObject *) ((wxPrintData *) x));
21060 }
21061 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21062 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21063 }
21064 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21065 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21066 }
21067 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21068 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21069 }
21070 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21071 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21072 }
21073 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21074 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21075 }
21076 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21077 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21078 }
21079 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21081 }
21082 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21084 }
21085 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21087 }
21088 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21090 }
21091 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21093 }
21094 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21096 }
21097 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21099 }
21100 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21102 }
21103 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21105 }
21106 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21108 }
21109 static void *_p_wxControlTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21111 }
21112 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21114 }
21115 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21117 }
21118 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) ((wxFSFile *) x));
21120 }
21121 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21123 }
21124 static void *_p_wxGridTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21126 }
21127 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21129 }
21130 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21132 }
21133 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) ((wxColourData *) x));
21135 }
21136 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21138 }
21139 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21141 }
21142 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21144 }
21145 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21147 }
21148 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21150 }
21151 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21153 }
21154 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21156 }
21157 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21159 }
21160 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21162 }
21163 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21165 }
21166 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21168 }
21169 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21171 }
21172 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21174 }
21175 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) ((wxPrinter *) x));
21177 }
21178 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) ((wxMenuItem *) x));
21180 }
21181 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21183 }
21184 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21186 }
21187 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21189 }
21190 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21192 }
21193 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21195 }
21196 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21198 }
21199 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21201 }
21202 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21204 }
21205 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21207 }
21208 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21210 }
21211 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21213 }
21214 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21216 }
21217 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21219 }
21220 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21222 }
21223 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21225 }
21226 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21228 }
21229 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21231 }
21232 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21234 }
21235 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21237 }
21238 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21240 }
21241 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) ((wxImageHandler *) x));
21243 }
21244 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21246 }
21247 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21249 }
21250 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) ((wxEvtHandler *) x));
21252 }
21253 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21255 }
21256 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21258 }
21259 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21261 }
21262 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21264 }
21265 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21267 }
21268 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21270 }
21271 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21273 }
21274 static void *_p_wxImageTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) ((wxImage *) x));
21276 }
21277 static void *_p_wxFrameTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21279 }
21280 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) ((wxPyPrintout *) x));
21282 }
21283 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21285 }
21286 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21288 }
21289 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21291 }
21292 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21294 }
21295 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21297 }
21298 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21300 }
21301 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21303 }
21304 static void *_p_wxWindowTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21306 }
21307 static void *_p_wxMenuTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21309 }
21310 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21312 }
21313 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21315 }
21316 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21318 }
21319 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21321 }
21322 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21324 }
21325 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21327 }
21328 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21330 }
21331 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21333 }
21334 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21336 }
21337 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21339 }
21340 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21342 }
21343 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21345 }
21346 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21348 }
21349 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21351 }
21352 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) ((wxPrintPreview *) x));
21354 }
21355 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21356 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21357 }
21358 static void *_p_wxPanelTo_p_wxObject(void *x) {
21359 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21360 }
21361 static void *_p_wxDialogTo_p_wxObject(void *x) {
21362 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21363 }
21364 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21365 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21366 }
21367 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21368 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21369 }
21370 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21371 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21372 }
21373 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21374 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21375 }
21376 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21377 return (void *)((wxObject *) ((wxPrintDialog *) x));
21378 }
21379 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21380 return (void *)((wxObject *) ((wxFileSystem *) x));
21381 }
21382 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21384 }
21385 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21386 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21387 }
21388 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21389 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21390 }
21391 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21392 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21393 }
21394 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21395 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21396 }
21397 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21398 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21399 }
21400 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21401 return (void *)((wxObject *) ((wxGridTableBase *) x));
21402 }
21403 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21404 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21405 }
21406 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21407 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21408 }
21409 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21410 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21411 }
21412 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21413 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21414 }
21415 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21416 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21417 }
21418 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21419 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21420 }
21421 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21422 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21423 }
21424 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21425 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21426 }
21427 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21428 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21429 }
21430 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21431 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21432 }
21433 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21434 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21435 }
21436 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21437 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21438 }
21439 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21440 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21441 }
21442 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21443 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21444 }
21445 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21446 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21447 }
21448 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21449 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21450 }
21451 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21452 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21453 }
21454 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21455 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21456 }
21457 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21458 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21459 }
21460 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21461 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21462 }
21463 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21464 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21465 }
21466 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21467 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21468 }
21469 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21470 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21471 }
21472 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21473 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21474 }
21475 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21476 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21477 }
21478 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21479 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21480 }
21481 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21482 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21483 }
21484 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21485 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21486 }
21487 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21488 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21489 }
21490 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21491 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21492 }
21493 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21494 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21495 }
21496 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21497 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21498 }
21499 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21500 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21501 }
21502 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21503 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21504 }
21505 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21506 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21507 }
21508 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21509 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21510 }
21511 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21512 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21513 }
21514 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21515 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21516 }
21517 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21518 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21519 }
21520 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21521 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21522 }
21523 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21524 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21525 }
21526 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21527 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21528 }
21529 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21530 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21531 }
21532 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21533 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21534 }
21535 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21536 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21537 }
21538 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21539 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21540 }
21541 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21542 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21543 }
21544 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21545 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21546 }
21547 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21548 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21549 }
21550 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21551 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21552 }
21553 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21554 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21555 }
21556 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21557 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21558 }
21559 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21560 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21561 }
21562 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21563 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21564 }
21565 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21566 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21567 }
21568 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21569 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21570 }
21571 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21572 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21573 }
21574 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21575 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21576 }
21577 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21578 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21579 }
21580 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21581 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21582 }
21583 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21584 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21585 }
21586 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21587 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21588 }
21589 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21590 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21591 }
21592 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21593 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21594 }
21595 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21596 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21597 }
21598 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21599 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21600 }
21601 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21602 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21603 }
21604 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21605 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21606 }
21607 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21608 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21609 }
21610 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21611 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21612 }
21613 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21614 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21615 }
21616 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21617 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21618 }
21619 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21620 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21621 }
21622 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21623 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21624 }
21625 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21626 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21627 }
21628 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21629 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21630 }
21631 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21632 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21633 }
21634 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21635 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21636 }
21637 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21638 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21639 }
21640 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21641 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21642 }
21643 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21644 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21645 }
21646 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21647 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21648 }
21649 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21650 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21651 }
21652 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21653 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21654 }
21655 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21656 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21657 }
21658 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21659 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21660 }
21661 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21662 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21663 }
21664 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21665 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21666 }
21667 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21668 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21669 }
21670 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21671 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21672 }
21673 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21674 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21675 }
21676 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21677 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21678 }
21679 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21680 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21681 }
21682 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21683 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21684 }
21685 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21686 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
21687 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21688 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21689 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21690 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21691 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21692 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21693 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21694 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21695 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21696 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21697 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21698 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21699 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21700 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21701 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21702 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21703 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21704 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21705 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21706 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21707 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21708 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21709 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21710 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21711 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21712 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21713 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21714 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21715 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21716 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21717 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21718 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21719 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21720 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21721 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21722 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21723 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21724 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21725 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21726 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21727 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21728 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21729 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21730 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21731 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21732 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21733 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21734 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21735 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21736 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21737 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21738 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21739 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21740 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21741 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21742 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21743 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21744 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21745 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21746 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21747 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21748 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21749 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21750 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21751 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21752 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21753 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21754 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21755 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21756 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21757 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21758 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21759 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21760 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21761 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21762 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21763 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21764 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21765 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21766 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21767 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21768 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21769 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21770 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21771 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21772 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21773 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21774 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21775 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21776 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21777 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21778 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21779 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21780 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21781 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21782 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21783 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21784 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21785 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21786 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21787 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21788 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21789 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21790 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21791 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21792 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21793 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21794 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21795 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21796 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21797 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21798 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21799 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21800 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21801 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21802 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21803 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21804 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21805 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21806 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21807 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21808 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21809 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21810 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21811 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21812 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21813 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21814 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21815 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21816 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21817 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21818 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21819 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21820 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21821 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21822 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21823 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21824 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21825 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21826 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21827 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21828 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21829 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21830 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21831 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21832 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21833 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21834 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21835 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21836 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21837 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21838 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21839 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21840 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21841 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21842 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21843 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21844 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21845 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21846 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21847 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21848 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21849 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
21850 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
21851 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
21852 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
21853 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
21854 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
21855 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
21856 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
21857 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
21858 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
21859 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
21860 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
21861 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
21862 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
21863 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
21864 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
21865 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
21866 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
21867 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
21868 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
21869 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
21870 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
21871
21872 static swig_type_info *swig_type_initial[] = {
21873 &_swigt__p_char,
21874 &_swigt__p_form_ops_t,
21875 &_swigt__p_int,
21876 &_swigt__p_long,
21877 &_swigt__p_unsigned_char,
21878 &_swigt__p_unsigned_int,
21879 &_swigt__p_unsigned_long,
21880 &_swigt__p_wxANIHandler,
21881 &_swigt__p_wxAcceleratorTable,
21882 &_swigt__p_wxActivateEvent,
21883 &_swigt__p_wxArrayString,
21884 &_swigt__p_wxBMPHandler,
21885 &_swigt__p_wxBoxSizer,
21886 &_swigt__p_wxCURHandler,
21887 &_swigt__p_wxCalculateLayoutEvent,
21888 &_swigt__p_wxChildFocusEvent,
21889 &_swigt__p_wxCloseEvent,
21890 &_swigt__p_wxColour,
21891 &_swigt__p_wxColourData,
21892 &_swigt__p_wxColourDialog,
21893 &_swigt__p_wxCommandEvent,
21894 &_swigt__p_wxContextMenuEvent,
21895 &_swigt__p_wxControl,
21896 &_swigt__p_wxControlWithItems,
21897 &_swigt__p_wxDC,
21898 &_swigt__p_wxDateEvent,
21899 &_swigt__p_wxDialog,
21900 &_swigt__p_wxDirDialog,
21901 &_swigt__p_wxDisplayChangedEvent,
21902 &_swigt__p_wxDropFilesEvent,
21903 &_swigt__p_wxDuplexMode,
21904 &_swigt__p_wxEraseEvent,
21905 &_swigt__p_wxEvent,
21906 &_swigt__p_wxEvtHandler,
21907 &_swigt__p_wxFSFile,
21908 &_swigt__p_wxFileDialog,
21909 &_swigt__p_wxFileSystem,
21910 &_swigt__p_wxFindDialogEvent,
21911 &_swigt__p_wxFindReplaceData,
21912 &_swigt__p_wxFindReplaceDialog,
21913 &_swigt__p_wxFlexGridSizer,
21914 &_swigt__p_wxFocusEvent,
21915 &_swigt__p_wxFont,
21916 &_swigt__p_wxFontData,
21917 &_swigt__p_wxFontDialog,
21918 &_swigt__p_wxFrame,
21919 &_swigt__p_wxGBSizerItem,
21920 &_swigt__p_wxGIFHandler,
21921 &_swigt__p_wxGrid,
21922 &_swigt__p_wxGridBagSizer,
21923 &_swigt__p_wxGridCellAttr,
21924 &_swigt__p_wxGridCellAttrProvider,
21925 &_swigt__p_wxGridCellAutoWrapStringEditor,
21926 &_swigt__p_wxGridCellAutoWrapStringRenderer,
21927 &_swigt__p_wxGridCellBoolEditor,
21928 &_swigt__p_wxGridCellBoolRenderer,
21929 &_swigt__p_wxGridCellChoiceEditor,
21930 &_swigt__p_wxGridCellCoords,
21931 &_swigt__p_wxGridCellDateTimeRenderer,
21932 &_swigt__p_wxGridCellEditor,
21933 &_swigt__p_wxGridCellEnumEditor,
21934 &_swigt__p_wxGridCellEnumRenderer,
21935 &_swigt__p_wxGridCellFloatEditor,
21936 &_swigt__p_wxGridCellFloatRenderer,
21937 &_swigt__p_wxGridCellNumberEditor,
21938 &_swigt__p_wxGridCellNumberRenderer,
21939 &_swigt__p_wxGridCellRenderer,
21940 &_swigt__p_wxGridCellStringRenderer,
21941 &_swigt__p_wxGridCellTextEditor,
21942 &_swigt__p_wxGridEditorCreatedEvent,
21943 &_swigt__p_wxGridEvent,
21944 &_swigt__p_wxGridRangeSelectEvent,
21945 &_swigt__p_wxGridSizeEvent,
21946 &_swigt__p_wxGridSizer,
21947 &_swigt__p_wxGridStringTable,
21948 &_swigt__p_wxGridTableBase,
21949 &_swigt__p_wxGridTableMessage,
21950 &_swigt__p_wxICOHandler,
21951 &_swigt__p_wxIconizeEvent,
21952 &_swigt__p_wxIdleEvent,
21953 &_swigt__p_wxImage,
21954 &_swigt__p_wxImageHandler,
21955 &_swigt__p_wxIndividualLayoutConstraint,
21956 &_swigt__p_wxInitDialogEvent,
21957 &_swigt__p_wxJPEGHandler,
21958 &_swigt__p_wxKeyEvent,
21959 &_swigt__p_wxLayoutAlgorithm,
21960 &_swigt__p_wxLayoutConstraints,
21961 &_swigt__p_wxMDIChildFrame,
21962 &_swigt__p_wxMDIClientWindow,
21963 &_swigt__p_wxMDIParentFrame,
21964 &_swigt__p_wxMaximizeEvent,
21965 &_swigt__p_wxMenu,
21966 &_swigt__p_wxMenuBar,
21967 &_swigt__p_wxMenuEvent,
21968 &_swigt__p_wxMenuItem,
21969 &_swigt__p_wxMessageDialog,
21970 &_swigt__p_wxMiniFrame,
21971 &_swigt__p_wxMouseCaptureChangedEvent,
21972 &_swigt__p_wxMouseEvent,
21973 &_swigt__p_wxMoveEvent,
21974 &_swigt__p_wxMultiChoiceDialog,
21975 &_swigt__p_wxNavigationKeyEvent,
21976 &_swigt__p_wxNcPaintEvent,
21977 &_swigt__p_wxNotifyEvent,
21978 &_swigt__p_wxObject,
21979 &_swigt__p_wxPCXHandler,
21980 &_swigt__p_wxPNGHandler,
21981 &_swigt__p_wxPNMHandler,
21982 &_swigt__p_wxPageSetupDialog,
21983 &_swigt__p_wxPageSetupDialogData,
21984 &_swigt__p_wxPaintEvent,
21985 &_swigt__p_wxPaletteChangedEvent,
21986 &_swigt__p_wxPanel,
21987 &_swigt__p_wxPaperSize,
21988 &_swigt__p_wxPasswordEntryDialog,
21989 &_swigt__p_wxPoint,
21990 &_swigt__p_wxPopupWindow,
21991 &_swigt__p_wxPreviewCanvas,
21992 &_swigt__p_wxPreviewControlBar,
21993 &_swigt__p_wxPreviewFrame,
21994 &_swigt__p_wxPrintData,
21995 &_swigt__p_wxPrintDialog,
21996 &_swigt__p_wxPrintDialogData,
21997 &_swigt__p_wxPrintPreview,
21998 &_swigt__p_wxPrinter,
21999 &_swigt__p_wxProgressDialog,
22000 &_swigt__p_wxPyApp,
22001 &_swigt__p_wxPyCommandEvent,
22002 &_swigt__p_wxPyEvent,
22003 &_swigt__p_wxPyGridCellAttrProvider,
22004 &_swigt__p_wxPyGridCellEditor,
22005 &_swigt__p_wxPyGridCellRenderer,
22006 &_swigt__p_wxPyGridTableBase,
22007 &_swigt__p_wxPyHtmlListBox,
22008 &_swigt__p_wxPyImageHandler,
22009 &_swigt__p_wxPyPanel,
22010 &_swigt__p_wxPyPopupTransientWindow,
22011 &_swigt__p_wxPyPreviewControlBar,
22012 &_swigt__p_wxPyPreviewFrame,
22013 &_swigt__p_wxPyPrintPreview,
22014 &_swigt__p_wxPyPrintout,
22015 &_swigt__p_wxPyScrolledWindow,
22016 &_swigt__p_wxPySizer,
22017 &_swigt__p_wxPyTaskBarIcon,
22018 &_swigt__p_wxPyVListBox,
22019 &_swigt__p_wxPyVScrolledWindow,
22020 &_swigt__p_wxPyValidator,
22021 &_swigt__p_wxPyWindow,
22022 &_swigt__p_wxQueryLayoutInfoEvent,
22023 &_swigt__p_wxQueryNewPaletteEvent,
22024 &_swigt__p_wxRect,
22025 &_swigt__p_wxSashEvent,
22026 &_swigt__p_wxSashLayoutWindow,
22027 &_swigt__p_wxSashWindow,
22028 &_swigt__p_wxScrollEvent,
22029 &_swigt__p_wxScrollWinEvent,
22030 &_swigt__p_wxScrolledWindow,
22031 &_swigt__p_wxSetCursorEvent,
22032 &_swigt__p_wxShowEvent,
22033 &_swigt__p_wxSingleChoiceDialog,
22034 &_swigt__p_wxSize,
22035 &_swigt__p_wxSizeEvent,
22036 &_swigt__p_wxSizer,
22037 &_swigt__p_wxSizerItem,
22038 &_swigt__p_wxSplashScreen,
22039 &_swigt__p_wxSplashScreenWindow,
22040 &_swigt__p_wxSplitterEvent,
22041 &_swigt__p_wxSplitterWindow,
22042 &_swigt__p_wxStaticBoxSizer,
22043 &_swigt__p_wxStatusBar,
22044 &_swigt__p_wxStdDialogButtonSizer,
22045 &_swigt__p_wxString,
22046 &_swigt__p_wxSysColourChangedEvent,
22047 &_swigt__p_wxTIFFHandler,
22048 &_swigt__p_wxTaskBarIconEvent,
22049 &_swigt__p_wxTextEntryDialog,
22050 &_swigt__p_wxTipWindow,
22051 &_swigt__p_wxTopLevelWindow,
22052 &_swigt__p_wxUpdateUIEvent,
22053 &_swigt__p_wxValidator,
22054 &_swigt__p_wxVisualAttributes,
22055 &_swigt__p_wxWindow,
22056 &_swigt__p_wxWindowCreateEvent,
22057 &_swigt__p_wxWindowDestroyEvent,
22058 &_swigt__p_wxXPMHandler,
22059 };
22060
22061 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22062 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22063 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22064 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22065 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22066 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22067 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22068 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22069 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22070 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22071 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22072 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22073 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22074 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22075 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22076 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22077 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22078 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22079 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22080 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22081 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
22082 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22083 static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},{0, 0, 0, 0}};
22084 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22085 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22086 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22087 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22088 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22089 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22090 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22091 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22092 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22093 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22094 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22095 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22096 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22097 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22098 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22099 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22100 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22101 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22102 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22103 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22104 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22105 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22106 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22107 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22108 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22109 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22110 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22111 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22112 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22113 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22114 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
22115 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22116 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22117 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22118 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22119 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22120 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22121 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22122 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22123 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22124 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22125 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22126 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22127 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22128 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22129 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22130 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22131 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22132 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22133 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22134 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22135 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22136 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22137 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22138 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22139 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22140 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22141 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22142 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22143 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22144 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22145 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22146 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22147 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22148 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22149 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22150 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22151 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22152 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22153 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22154 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22155 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22156 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22157 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22158 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22159 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22160 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22161 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22162 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22163 static swig_cast_info _swigc__p_wxGridCellAttrProvider[] = { {&_swigt__p_wxGridCellAttrProvider, 0, 0, 0}, {&_swigt__p_wxPyGridCellAttrProvider, _p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider, 0, 0},{0, 0, 0, 0}};
22164 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22165 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22166 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22167 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22168 static swig_cast_info _swigc__p_wxGridCellChoiceEditor[] = { {&_swigt__p_wxGridCellChoiceEditor, 0, 0, 0}, {&_swigt__p_wxGridCellEnumEditor, _p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor, 0, 0},{0, 0, 0, 0}};
22169 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22170 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22171 static swig_cast_info _swigc__p_wxGridCellEditor[] = { {&_swigt__p_wxGridCellEditor, 0, 0, 0}, {&_swigt__p_wxPyGridCellEditor, _p_wxPyGridCellEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellTextEditor, _p_wxGridCellTextEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellNumberEditor, _p_wxGridCellNumberEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellFloatEditor, _p_wxGridCellFloatEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellBoolEditor, _p_wxGridCellBoolEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringEditor, _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellChoiceEditor, _p_wxGridCellChoiceEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellEnumEditor, _p_wxGridCellEnumEditorTo_p_wxGridCellEditor, 0, 0},{0, 0, 0, 0}};
22172 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22173 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22174 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22175 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22176 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22177 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22178 static swig_cast_info _swigc__p_wxGridCellRenderer[] = { {&_swigt__p_wxGridCellRenderer, 0, 0, 0}, {&_swigt__p_wxPyGridCellRenderer, _p_wxPyGridCellRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellStringRenderer, _p_wxGridCellStringRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellNumberRenderer, _p_wxGridCellNumberRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellFloatRenderer, _p_wxGridCellFloatRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellDateTimeRenderer, _p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellEnumRenderer, _p_wxGridCellEnumRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringRenderer, _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellBoolRenderer, _p_wxGridCellBoolRendererTo_p_wxGridCellRenderer, 0, 0},{0, 0, 0, 0}};
22179 static swig_cast_info _swigc__p_wxGridCellStringRenderer[] = { {&_swigt__p_wxGridCellStringRenderer, 0, 0, 0}, {&_swigt__p_wxGridCellNumberRenderer, _p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellFloatRenderer, _p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellDateTimeRenderer, _p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellEnumRenderer, _p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringRenderer, _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer, 0, 0},{0, 0, 0, 0}};
22180 static swig_cast_info _swigc__p_wxGridCellTextEditor[] = { {&_swigt__p_wxGridCellTextEditor, 0, 0, 0}, {&_swigt__p_wxGridCellNumberEditor, _p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor, 0, 0}, {&_swigt__p_wxGridCellFloatEditor, _p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringEditor, _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor, 0, 0},{0, 0, 0, 0}};
22181 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22182 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22183 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22184 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22185 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22186 static swig_cast_info _swigc__p_wxGridTableBase[] = { {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxGridTableBase, 0, 0}, {&_swigt__p_wxGridTableBase, 0, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxGridTableBase, 0, 0},{0, 0, 0, 0}};
22187 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22188 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22189 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
22190 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22191 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22192 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22193 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22194 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22195 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22196 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22197 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22198 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22199 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22200 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22201 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22202 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22203 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22204 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22205 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22206 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22207 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22208 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22209 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22210 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22211 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22212 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22213 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22214 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22215 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22216 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22217 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22218 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22219 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22220 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22221 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22222 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22223 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22224 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22225 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22226 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22227 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22228 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22229 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22230 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22231 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22232 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22233 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22234 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22235 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22236 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22237 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22238 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22239 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22240 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22241 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22242 static swig_cast_info _swigc__p_wxScrolledWindow[] = { {&_swigt__p_wxGrid, _p_wxGridTo_p_wxScrolledWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, 0, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxScrolledWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxScrolledWindow, 0, 0},{0, 0, 0, 0}};
22243 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22244 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22245 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22246 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22247
22248 static swig_cast_info *swig_cast_initial[] = {
22249 _swigc__p_char,
22250 _swigc__p_form_ops_t,
22251 _swigc__p_int,
22252 _swigc__p_long,
22253 _swigc__p_unsigned_char,
22254 _swigc__p_unsigned_int,
22255 _swigc__p_unsigned_long,
22256 _swigc__p_wxANIHandler,
22257 _swigc__p_wxAcceleratorTable,
22258 _swigc__p_wxActivateEvent,
22259 _swigc__p_wxArrayString,
22260 _swigc__p_wxBMPHandler,
22261 _swigc__p_wxBoxSizer,
22262 _swigc__p_wxCURHandler,
22263 _swigc__p_wxCalculateLayoutEvent,
22264 _swigc__p_wxChildFocusEvent,
22265 _swigc__p_wxCloseEvent,
22266 _swigc__p_wxColour,
22267 _swigc__p_wxColourData,
22268 _swigc__p_wxColourDialog,
22269 _swigc__p_wxCommandEvent,
22270 _swigc__p_wxContextMenuEvent,
22271 _swigc__p_wxControl,
22272 _swigc__p_wxControlWithItems,
22273 _swigc__p_wxDC,
22274 _swigc__p_wxDateEvent,
22275 _swigc__p_wxDialog,
22276 _swigc__p_wxDirDialog,
22277 _swigc__p_wxDisplayChangedEvent,
22278 _swigc__p_wxDropFilesEvent,
22279 _swigc__p_wxDuplexMode,
22280 _swigc__p_wxEraseEvent,
22281 _swigc__p_wxEvent,
22282 _swigc__p_wxEvtHandler,
22283 _swigc__p_wxFSFile,
22284 _swigc__p_wxFileDialog,
22285 _swigc__p_wxFileSystem,
22286 _swigc__p_wxFindDialogEvent,
22287 _swigc__p_wxFindReplaceData,
22288 _swigc__p_wxFindReplaceDialog,
22289 _swigc__p_wxFlexGridSizer,
22290 _swigc__p_wxFocusEvent,
22291 _swigc__p_wxFont,
22292 _swigc__p_wxFontData,
22293 _swigc__p_wxFontDialog,
22294 _swigc__p_wxFrame,
22295 _swigc__p_wxGBSizerItem,
22296 _swigc__p_wxGIFHandler,
22297 _swigc__p_wxGrid,
22298 _swigc__p_wxGridBagSizer,
22299 _swigc__p_wxGridCellAttr,
22300 _swigc__p_wxGridCellAttrProvider,
22301 _swigc__p_wxGridCellAutoWrapStringEditor,
22302 _swigc__p_wxGridCellAutoWrapStringRenderer,
22303 _swigc__p_wxGridCellBoolEditor,
22304 _swigc__p_wxGridCellBoolRenderer,
22305 _swigc__p_wxGridCellChoiceEditor,
22306 _swigc__p_wxGridCellCoords,
22307 _swigc__p_wxGridCellDateTimeRenderer,
22308 _swigc__p_wxGridCellEditor,
22309 _swigc__p_wxGridCellEnumEditor,
22310 _swigc__p_wxGridCellEnumRenderer,
22311 _swigc__p_wxGridCellFloatEditor,
22312 _swigc__p_wxGridCellFloatRenderer,
22313 _swigc__p_wxGridCellNumberEditor,
22314 _swigc__p_wxGridCellNumberRenderer,
22315 _swigc__p_wxGridCellRenderer,
22316 _swigc__p_wxGridCellStringRenderer,
22317 _swigc__p_wxGridCellTextEditor,
22318 _swigc__p_wxGridEditorCreatedEvent,
22319 _swigc__p_wxGridEvent,
22320 _swigc__p_wxGridRangeSelectEvent,
22321 _swigc__p_wxGridSizeEvent,
22322 _swigc__p_wxGridSizer,
22323 _swigc__p_wxGridStringTable,
22324 _swigc__p_wxGridTableBase,
22325 _swigc__p_wxGridTableMessage,
22326 _swigc__p_wxICOHandler,
22327 _swigc__p_wxIconizeEvent,
22328 _swigc__p_wxIdleEvent,
22329 _swigc__p_wxImage,
22330 _swigc__p_wxImageHandler,
22331 _swigc__p_wxIndividualLayoutConstraint,
22332 _swigc__p_wxInitDialogEvent,
22333 _swigc__p_wxJPEGHandler,
22334 _swigc__p_wxKeyEvent,
22335 _swigc__p_wxLayoutAlgorithm,
22336 _swigc__p_wxLayoutConstraints,
22337 _swigc__p_wxMDIChildFrame,
22338 _swigc__p_wxMDIClientWindow,
22339 _swigc__p_wxMDIParentFrame,
22340 _swigc__p_wxMaximizeEvent,
22341 _swigc__p_wxMenu,
22342 _swigc__p_wxMenuBar,
22343 _swigc__p_wxMenuEvent,
22344 _swigc__p_wxMenuItem,
22345 _swigc__p_wxMessageDialog,
22346 _swigc__p_wxMiniFrame,
22347 _swigc__p_wxMouseCaptureChangedEvent,
22348 _swigc__p_wxMouseEvent,
22349 _swigc__p_wxMoveEvent,
22350 _swigc__p_wxMultiChoiceDialog,
22351 _swigc__p_wxNavigationKeyEvent,
22352 _swigc__p_wxNcPaintEvent,
22353 _swigc__p_wxNotifyEvent,
22354 _swigc__p_wxObject,
22355 _swigc__p_wxPCXHandler,
22356 _swigc__p_wxPNGHandler,
22357 _swigc__p_wxPNMHandler,
22358 _swigc__p_wxPageSetupDialog,
22359 _swigc__p_wxPageSetupDialogData,
22360 _swigc__p_wxPaintEvent,
22361 _swigc__p_wxPaletteChangedEvent,
22362 _swigc__p_wxPanel,
22363 _swigc__p_wxPaperSize,
22364 _swigc__p_wxPasswordEntryDialog,
22365 _swigc__p_wxPoint,
22366 _swigc__p_wxPopupWindow,
22367 _swigc__p_wxPreviewCanvas,
22368 _swigc__p_wxPreviewControlBar,
22369 _swigc__p_wxPreviewFrame,
22370 _swigc__p_wxPrintData,
22371 _swigc__p_wxPrintDialog,
22372 _swigc__p_wxPrintDialogData,
22373 _swigc__p_wxPrintPreview,
22374 _swigc__p_wxPrinter,
22375 _swigc__p_wxProgressDialog,
22376 _swigc__p_wxPyApp,
22377 _swigc__p_wxPyCommandEvent,
22378 _swigc__p_wxPyEvent,
22379 _swigc__p_wxPyGridCellAttrProvider,
22380 _swigc__p_wxPyGridCellEditor,
22381 _swigc__p_wxPyGridCellRenderer,
22382 _swigc__p_wxPyGridTableBase,
22383 _swigc__p_wxPyHtmlListBox,
22384 _swigc__p_wxPyImageHandler,
22385 _swigc__p_wxPyPanel,
22386 _swigc__p_wxPyPopupTransientWindow,
22387 _swigc__p_wxPyPreviewControlBar,
22388 _swigc__p_wxPyPreviewFrame,
22389 _swigc__p_wxPyPrintPreview,
22390 _swigc__p_wxPyPrintout,
22391 _swigc__p_wxPyScrolledWindow,
22392 _swigc__p_wxPySizer,
22393 _swigc__p_wxPyTaskBarIcon,
22394 _swigc__p_wxPyVListBox,
22395 _swigc__p_wxPyVScrolledWindow,
22396 _swigc__p_wxPyValidator,
22397 _swigc__p_wxPyWindow,
22398 _swigc__p_wxQueryLayoutInfoEvent,
22399 _swigc__p_wxQueryNewPaletteEvent,
22400 _swigc__p_wxRect,
22401 _swigc__p_wxSashEvent,
22402 _swigc__p_wxSashLayoutWindow,
22403 _swigc__p_wxSashWindow,
22404 _swigc__p_wxScrollEvent,
22405 _swigc__p_wxScrollWinEvent,
22406 _swigc__p_wxScrolledWindow,
22407 _swigc__p_wxSetCursorEvent,
22408 _swigc__p_wxShowEvent,
22409 _swigc__p_wxSingleChoiceDialog,
22410 _swigc__p_wxSize,
22411 _swigc__p_wxSizeEvent,
22412 _swigc__p_wxSizer,
22413 _swigc__p_wxSizerItem,
22414 _swigc__p_wxSplashScreen,
22415 _swigc__p_wxSplashScreenWindow,
22416 _swigc__p_wxSplitterEvent,
22417 _swigc__p_wxSplitterWindow,
22418 _swigc__p_wxStaticBoxSizer,
22419 _swigc__p_wxStatusBar,
22420 _swigc__p_wxStdDialogButtonSizer,
22421 _swigc__p_wxString,
22422 _swigc__p_wxSysColourChangedEvent,
22423 _swigc__p_wxTIFFHandler,
22424 _swigc__p_wxTaskBarIconEvent,
22425 _swigc__p_wxTextEntryDialog,
22426 _swigc__p_wxTipWindow,
22427 _swigc__p_wxTopLevelWindow,
22428 _swigc__p_wxUpdateUIEvent,
22429 _swigc__p_wxValidator,
22430 _swigc__p_wxVisualAttributes,
22431 _swigc__p_wxWindow,
22432 _swigc__p_wxWindowCreateEvent,
22433 _swigc__p_wxWindowDestroyEvent,
22434 _swigc__p_wxXPMHandler,
22435 };
22436
22437
22438 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22439
22440 static swig_const_info swig_const_table[] = {
22441 {0, 0, 0, 0.0, 0, 0}};
22442
22443 #ifdef __cplusplus
22444 }
22445 #endif
22446 /* -----------------------------------------------------------------------------
22447 * Type initialization:
22448 * This problem is tough by the requirement that no dynamic
22449 * memory is used. Also, since swig_type_info structures store pointers to
22450 * swig_cast_info structures and swig_cast_info structures store pointers back
22451 * to swig_type_info structures, we need some lookup code at initialization.
22452 * The idea is that swig generates all the structures that are needed.
22453 * The runtime then collects these partially filled structures.
22454 * The SWIG_InitializeModule function takes these initial arrays out of
22455 * swig_module, and does all the lookup, filling in the swig_module.types
22456 * array with the correct data and linking the correct swig_cast_info
22457 * structures together.
22458 *
22459 * The generated swig_type_info structures are assigned staticly to an initial
22460 * array. We just loop though that array, and handle each type individually.
22461 * First we lookup if this type has been already loaded, and if so, use the
22462 * loaded structure instead of the generated one. Then we have to fill in the
22463 * cast linked list. The cast data is initially stored in something like a
22464 * two-dimensional array. Each row corresponds to a type (there are the same
22465 * number of rows as there are in the swig_type_initial array). Each entry in
22466 * a column is one of the swig_cast_info structures for that type.
22467 * The cast_initial array is actually an array of arrays, because each row has
22468 * a variable number of columns. So to actually build the cast linked list,
22469 * we find the array of casts associated with the type, and loop through it
22470 * adding the casts to the list. The one last trick we need to do is making
22471 * sure the type pointer in the swig_cast_info struct is correct.
22472 *
22473 * First off, we lookup the cast->type name to see if it is already loaded.
22474 * There are three cases to handle:
22475 * 1) If the cast->type has already been loaded AND the type we are adding
22476 * casting info to has not been loaded (it is in this module), THEN we
22477 * replace the cast->type pointer with the type pointer that has already
22478 * been loaded.
22479 * 2) If BOTH types (the one we are adding casting info to, and the
22480 * cast->type) are loaded, THEN the cast info has already been loaded by
22481 * the previous module so we just ignore it.
22482 * 3) Finally, if cast->type has not already been loaded, then we add that
22483 * swig_cast_info to the linked list (because the cast->type) pointer will
22484 * be correct.
22485 * ----------------------------------------------------------------------------- */
22486
22487 #ifdef __cplusplus
22488 extern "C" {
22489 #if 0
22490 } /* c-mode */
22491 #endif
22492 #endif
22493
22494 #if 0
22495 #define SWIGRUNTIME_DEBUG
22496 #endif
22497
22498 SWIGRUNTIME void
22499 SWIG_InitializeModule(void *clientdata) {
22500 size_t i;
22501 swig_module_info *module_head;
22502 static int init_run = 0;
22503
22504 clientdata = clientdata;
22505
22506 if (init_run) return;
22507 init_run = 1;
22508
22509 /* Initialize the swig_module */
22510 swig_module.type_initial = swig_type_initial;
22511 swig_module.cast_initial = swig_cast_initial;
22512
22513 /* Try and load any already created modules */
22514 module_head = SWIG_GetModule(clientdata);
22515 if (module_head) {
22516 swig_module.next = module_head->next;
22517 module_head->next = &swig_module;
22518 } else {
22519 /* This is the first module loaded */
22520 swig_module.next = &swig_module;
22521 SWIG_SetModule(clientdata, &swig_module);
22522 }
22523
22524 /* Now work on filling in swig_module.types */
22525 #ifdef SWIGRUNTIME_DEBUG
22526 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22527 #endif
22528 for (i = 0; i < swig_module.size; ++i) {
22529 swig_type_info *type = 0;
22530 swig_type_info *ret;
22531 swig_cast_info *cast;
22532
22533 #ifdef SWIGRUNTIME_DEBUG
22534 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22535 #endif
22536
22537 /* if there is another module already loaded */
22538 if (swig_module.next != &swig_module) {
22539 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22540 }
22541 if (type) {
22542 /* Overwrite clientdata field */
22543 #ifdef SWIGRUNTIME_DEBUG
22544 printf("SWIG_InitializeModule: found type %s\n", type->name);
22545 #endif
22546 if (swig_module.type_initial[i]->clientdata) {
22547 type->clientdata = swig_module.type_initial[i]->clientdata;
22548 #ifdef SWIGRUNTIME_DEBUG
22549 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22550 #endif
22551 }
22552 } else {
22553 type = swig_module.type_initial[i];
22554 }
22555
22556 /* Insert casting types */
22557 cast = swig_module.cast_initial[i];
22558 while (cast->type) {
22559 /* Don't need to add information already in the list */
22560 ret = 0;
22561 #ifdef SWIGRUNTIME_DEBUG
22562 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22563 #endif
22564 if (swig_module.next != &swig_module) {
22565 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22566 #ifdef SWIGRUNTIME_DEBUG
22567 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22568 #endif
22569 }
22570 if (ret) {
22571 if (type == swig_module.type_initial[i]) {
22572 #ifdef SWIGRUNTIME_DEBUG
22573 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22574 #endif
22575 cast->type = ret;
22576 ret = 0;
22577 } else {
22578 /* Check for casting already in the list */
22579 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22580 #ifdef SWIGRUNTIME_DEBUG
22581 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22582 #endif
22583 if (!ocast) ret = 0;
22584 }
22585 }
22586
22587 if (!ret) {
22588 #ifdef SWIGRUNTIME_DEBUG
22589 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22590 #endif
22591 if (type->cast) {
22592 type->cast->prev = cast;
22593 cast->next = type->cast;
22594 }
22595 type->cast = cast;
22596 }
22597 cast++;
22598 }
22599 /* Set entry in modules->types array equal to the type */
22600 swig_module.types[i] = type;
22601 }
22602 swig_module.types[i] = 0;
22603
22604 #ifdef SWIGRUNTIME_DEBUG
22605 printf("**** SWIG_InitializeModule: Cast List ******\n");
22606 for (i = 0; i < swig_module.size; ++i) {
22607 int j = 0;
22608 swig_cast_info *cast = swig_module.cast_initial[i];
22609 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22610 while (cast->type) {
22611 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22612 cast++;
22613 ++j;
22614 }
22615 printf("---- Total casts: %d\n",j);
22616 }
22617 printf("**** SWIG_InitializeModule: Cast List ******\n");
22618 #endif
22619 }
22620
22621 /* This function will propagate the clientdata field of type to
22622 * any new swig_type_info structures that have been added into the list
22623 * of equivalent types. It is like calling
22624 * SWIG_TypeClientData(type, clientdata) a second time.
22625 */
22626 SWIGRUNTIME void
22627 SWIG_PropagateClientData(void) {
22628 size_t i;
22629 swig_cast_info *equiv;
22630 static int init_run = 0;
22631
22632 if (init_run) return;
22633 init_run = 1;
22634
22635 for (i = 0; i < swig_module.size; i++) {
22636 if (swig_module.types[i]->clientdata) {
22637 equiv = swig_module.types[i]->cast;
22638 while (equiv) {
22639 if (!equiv->converter) {
22640 if (equiv->type && !equiv->type->clientdata)
22641 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22642 }
22643 equiv = equiv->next;
22644 }
22645 }
22646 }
22647 }
22648
22649 #ifdef __cplusplus
22650 #if 0
22651 {
22652 /* c-mode */
22653 #endif
22654 }
22655 #endif
22656
22657
22658
22659 #ifdef __cplusplus
22660 extern "C" {
22661 #endif
22662
22663 /* Python-specific SWIG API */
22664 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22665 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22666 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22667
22668 /* -----------------------------------------------------------------------------
22669 * global variable support code.
22670 * ----------------------------------------------------------------------------- */
22671
22672 typedef struct swig_globalvar {
22673 char *name; /* Name of global variable */
22674 PyObject *(*get_attr)(void); /* Return the current value */
22675 int (*set_attr)(PyObject *); /* Set the value */
22676 struct swig_globalvar *next;
22677 } swig_globalvar;
22678
22679 typedef struct swig_varlinkobject {
22680 PyObject_HEAD
22681 swig_globalvar *vars;
22682 } swig_varlinkobject;
22683
22684 SWIGINTERN PyObject *
22685 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22686 return PyString_FromString("<Swig global variables>");
22687 }
22688
22689 SWIGINTERN PyObject *
22690 swig_varlink_str(swig_varlinkobject *v) {
22691 PyObject *str = PyString_FromString("(");
22692 swig_globalvar *var;
22693 for (var = v->vars; var; var=var->next) {
22694 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22695 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22696 }
22697 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22698 return str;
22699 }
22700
22701 SWIGINTERN int
22702 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22703 PyObject *str = swig_varlink_str(v);
22704 fprintf(fp,"Swig global variables ");
22705 fprintf(fp,"%s\n", PyString_AsString(str));
22706 Py_DECREF(str);
22707 return 0;
22708 }
22709
22710 SWIGINTERN void
22711 swig_varlink_dealloc(swig_varlinkobject *v) {
22712 swig_globalvar *var = v->vars;
22713 while (var) {
22714 swig_globalvar *n = var->next;
22715 free(var->name);
22716 free(var);
22717 var = n;
22718 }
22719 }
22720
22721 SWIGINTERN PyObject *
22722 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22723 PyObject *res = NULL;
22724 swig_globalvar *var = v->vars;
22725 while (var) {
22726 if (strcmp(var->name,n) == 0) {
22727 res = (*var->get_attr)();
22728 break;
22729 }
22730 var = var->next;
22731 }
22732 if (res == NULL && !PyErr_Occurred()) {
22733 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22734 }
22735 return res;
22736 }
22737
22738 SWIGINTERN int
22739 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22740 int res = 1;
22741 swig_globalvar *var = v->vars;
22742 while (var) {
22743 if (strcmp(var->name,n) == 0) {
22744 res = (*var->set_attr)(p);
22745 break;
22746 }
22747 var = var->next;
22748 }
22749 if (res == 1 && !PyErr_Occurred()) {
22750 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22751 }
22752 return res;
22753 }
22754
22755 SWIGINTERN PyTypeObject*
22756 swig_varlink_type(void) {
22757 static char varlink__doc__[] = "Swig var link object";
22758 static PyTypeObject varlink_type;
22759 static int type_init = 0;
22760 if (!type_init) {
22761 const PyTypeObject tmp
22762 = {
22763 PyObject_HEAD_INIT(NULL)
22764 0, /* Number of items in variable part (ob_size) */
22765 (char *)"swigvarlink", /* Type name (tp_name) */
22766 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22767 0, /* Itemsize (tp_itemsize) */
22768 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22769 (printfunc) swig_varlink_print, /* Print (tp_print) */
22770 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22771 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22772 0, /* tp_compare */
22773 (reprfunc) swig_varlink_repr, /* tp_repr */
22774 0, /* tp_as_number */
22775 0, /* tp_as_sequence */
22776 0, /* tp_as_mapping */
22777 0, /* tp_hash */
22778 0, /* tp_call */
22779 (reprfunc)swig_varlink_str, /* tp_str */
22780 0, /* tp_getattro */
22781 0, /* tp_setattro */
22782 0, /* tp_as_buffer */
22783 0, /* tp_flags */
22784 varlink__doc__, /* tp_doc */
22785 0, /* tp_traverse */
22786 0, /* tp_clear */
22787 0, /* tp_richcompare */
22788 0, /* tp_weaklistoffset */
22789 #if PY_VERSION_HEX >= 0x02020000
22790 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22791 #endif
22792 #if PY_VERSION_HEX >= 0x02030000
22793 0, /* tp_del */
22794 #endif
22795 #ifdef COUNT_ALLOCS
22796 0,0,0,0 /* tp_alloc -> tp_next */
22797 #endif
22798 };
22799 varlink_type = tmp;
22800 varlink_type.ob_type = &PyType_Type;
22801 type_init = 1;
22802 }
22803 return &varlink_type;
22804 }
22805
22806 /* Create a variable linking object for use later */
22807 SWIGINTERN PyObject *
22808 SWIG_Python_newvarlink(void) {
22809 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22810 if (result) {
22811 result->vars = 0;
22812 }
22813 return ((PyObject*) result);
22814 }
22815
22816 SWIGINTERN void
22817 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22818 swig_varlinkobject *v = (swig_varlinkobject *) p;
22819 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22820 if (gv) {
22821 size_t size = strlen(name)+1;
22822 gv->name = (char *)malloc(size);
22823 if (gv->name) {
22824 strncpy(gv->name,name,size);
22825 gv->get_attr = get_attr;
22826 gv->set_attr = set_attr;
22827 gv->next = v->vars;
22828 }
22829 }
22830 v->vars = gv;
22831 }
22832
22833 SWIGINTERN PyObject *
22834 SWIG_globals() {
22835 static PyObject *_SWIG_globals = 0;
22836 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22837 return _SWIG_globals;
22838 }
22839
22840 /* -----------------------------------------------------------------------------
22841 * constants/methods manipulation
22842 * ----------------------------------------------------------------------------- */
22843
22844 /* Install Constants */
22845 SWIGINTERN void
22846 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22847 PyObject *obj = 0;
22848 size_t i;
22849 for (i = 0; constants[i].type; ++i) {
22850 switch(constants[i].type) {
22851 case SWIG_PY_POINTER:
22852 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22853 break;
22854 case SWIG_PY_BINARY:
22855 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22856 break;
22857 default:
22858 obj = 0;
22859 break;
22860 }
22861 if (obj) {
22862 PyDict_SetItemString(d, constants[i].name, obj);
22863 Py_DECREF(obj);
22864 }
22865 }
22866 }
22867
22868 /* -----------------------------------------------------------------------------*/
22869 /* Fix SwigMethods to carry the callback ptrs when needed */
22870 /* -----------------------------------------------------------------------------*/
22871
22872 SWIGINTERN void
22873 SWIG_Python_FixMethods(PyMethodDef *methods,
22874 swig_const_info *const_table,
22875 swig_type_info **types,
22876 swig_type_info **types_initial) {
22877 size_t i;
22878 for (i = 0; methods[i].ml_name; ++i) {
22879 char *c = methods[i].ml_doc;
22880 if (c && (c = strstr(c, "swig_ptr: "))) {
22881 int j;
22882 swig_const_info *ci = 0;
22883 char *name = c + 10;
22884 for (j = 0; const_table[j].type; ++j) {
22885 if (strncmp(const_table[j].name, name,
22886 strlen(const_table[j].name)) == 0) {
22887 ci = &(const_table[j]);
22888 break;
22889 }
22890 }
22891 if (ci) {
22892 size_t shift = (ci->ptype) - types;
22893 swig_type_info *ty = types_initial[shift];
22894 size_t ldoc = (c - methods[i].ml_doc);
22895 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22896 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22897 if (ndoc) {
22898 char *buff = ndoc;
22899 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22900 if (ptr) {
22901 strncpy(buff, methods[i].ml_doc, ldoc);
22902 buff += ldoc;
22903 strncpy(buff, "swig_ptr: ", 10);
22904 buff += 10;
22905 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22906 methods[i].ml_doc = ndoc;
22907 }
22908 }
22909 }
22910 }
22911 }
22912 }
22913
22914 #ifdef __cplusplus
22915 }
22916 #endif
22917
22918 /* -----------------------------------------------------------------------------*
22919 * Partial Init method
22920 * -----------------------------------------------------------------------------*/
22921
22922 #ifdef __cplusplus
22923 extern "C"
22924 #endif
22925 SWIGEXPORT void SWIG_init(void) {
22926 PyObject *m, *d;
22927
22928 /* Fix SwigMethods to carry the callback ptrs when needed */
22929 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
22930
22931 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22932 d = PyModule_GetDict(m);
22933
22934 SWIG_InitializeModule(0);
22935 SWIG_InstallConstants(d,swig_const_table);
22936
22937
22938 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
22939 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
22940 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
22941 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
22942 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
22943 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
22944 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
22945 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
22946 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
22947 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
22948 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
22949 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
22950 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
22951 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
22952 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
22953 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
22954 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
22955 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
22956 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
22957 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
22958 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
22959 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
22960 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
22961 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
22962 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
22963 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
22964 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
22965 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
22966 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
22967 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
22968 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
22969 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
22970 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
22971 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
22972 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
22973 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
22974 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
22975 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
22976 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
22977 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
22978 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
22979 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
22980 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
22981 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
22982 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
22983 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
22984 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
22985 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
22986 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
22987 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
22988 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
22989 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
22990 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
22991 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
22992 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
22993 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
22994
22995
22996 }
22997
wxWidgets (Impactor)