]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use correct DLL import/export specifier for multi-lib builds
[wxWidgets.git] / wxPython / src / msw / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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_wxGridCellWorker swig_types[69]
2532 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[70]
2533 #define SWIGTYPE_p_wxGridEvent swig_types[71]
2534 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[72]
2535 #define SWIGTYPE_p_wxGridSizeEvent swig_types[73]
2536 #define SWIGTYPE_p_wxGridSizer swig_types[74]
2537 #define SWIGTYPE_p_wxGridStringTable swig_types[75]
2538 #define SWIGTYPE_p_wxGridTableBase swig_types[76]
2539 #define SWIGTYPE_p_wxGridTableMessage swig_types[77]
2540 #define SWIGTYPE_p_wxICOHandler swig_types[78]
2541 #define SWIGTYPE_p_wxIconizeEvent swig_types[79]
2542 #define SWIGTYPE_p_wxIdleEvent swig_types[80]
2543 #define SWIGTYPE_p_wxImage swig_types[81]
2544 #define SWIGTYPE_p_wxImageHandler swig_types[82]
2545 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[83]
2546 #define SWIGTYPE_p_wxInitDialogEvent swig_types[84]
2547 #define SWIGTYPE_p_wxJPEGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxKeyEvent swig_types[86]
2549 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[87]
2550 #define SWIGTYPE_p_wxLayoutConstraints swig_types[88]
2551 #define SWIGTYPE_p_wxMDIChildFrame swig_types[89]
2552 #define SWIGTYPE_p_wxMDIClientWindow swig_types[90]
2553 #define SWIGTYPE_p_wxMDIParentFrame swig_types[91]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenu swig_types[93]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[94]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[95]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[96]
2559 #define SWIGTYPE_p_wxMessageDialog swig_types[97]
2560 #define SWIGTYPE_p_wxMiniFrame swig_types[98]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMouseEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2564 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[102]
2565 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2567 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2568 #define SWIGTYPE_p_wxObject swig_types[106]
2569 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPageSetupDialog swig_types[110]
2573 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[111]
2574 #define SWIGTYPE_p_wxPaintEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPanel swig_types[114]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[115]
2578 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[116]
2579 #define SWIGTYPE_p_wxPoint swig_types[117]
2580 #define SWIGTYPE_p_wxPopupWindow swig_types[118]
2581 #define SWIGTYPE_p_wxPreviewCanvas swig_types[119]
2582 #define SWIGTYPE_p_wxPreviewControlBar swig_types[120]
2583 #define SWIGTYPE_p_wxPreviewFrame swig_types[121]
2584 #define SWIGTYPE_p_wxPrintData swig_types[122]
2585 #define SWIGTYPE_p_wxPrintDialog swig_types[123]
2586 #define SWIGTYPE_p_wxPrintDialogData swig_types[124]
2587 #define SWIGTYPE_p_wxPrintPreview swig_types[125]
2588 #define SWIGTYPE_p_wxPrinter swig_types[126]
2589 #define SWIGTYPE_p_wxProgressDialog swig_types[127]
2590 #define SWIGTYPE_p_wxPyApp swig_types[128]
2591 #define SWIGTYPE_p_wxPyCommandEvent swig_types[129]
2592 #define SWIGTYPE_p_wxPyEvent swig_types[130]
2593 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[131]
2594 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[132]
2595 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[133]
2596 #define SWIGTYPE_p_wxPyGridTableBase swig_types[134]
2597 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[135]
2598 #define SWIGTYPE_p_wxPyImageHandler swig_types[136]
2599 #define SWIGTYPE_p_wxPyPanel swig_types[137]
2600 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[138]
2601 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[139]
2602 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[140]
2603 #define SWIGTYPE_p_wxPyPrintPreview swig_types[141]
2604 #define SWIGTYPE_p_wxPyPrintout swig_types[142]
2605 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[143]
2606 #define SWIGTYPE_p_wxPySizer swig_types[144]
2607 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[145]
2608 #define SWIGTYPE_p_wxPyVListBox swig_types[146]
2609 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[147]
2610 #define SWIGTYPE_p_wxPyValidator swig_types[148]
2611 #define SWIGTYPE_p_wxPyWindow swig_types[149]
2612 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[150]
2613 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[151]
2614 #define SWIGTYPE_p_wxRect swig_types[152]
2615 #define SWIGTYPE_p_wxSashEvent swig_types[153]
2616 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[154]
2617 #define SWIGTYPE_p_wxSashWindow swig_types[155]
2618 #define SWIGTYPE_p_wxScrollEvent swig_types[156]
2619 #define SWIGTYPE_p_wxScrollWinEvent swig_types[157]
2620 #define SWIGTYPE_p_wxScrolledWindow swig_types[158]
2621 #define SWIGTYPE_p_wxSetCursorEvent swig_types[159]
2622 #define SWIGTYPE_p_wxShowEvent swig_types[160]
2623 #define SWIGTYPE_p_wxSingleChoiceDialog 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 wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3199 if (!self->GetClientObject())
3200 self->SetClientObject(new wxPyOORClientData(_self));
3201 }
3202 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3203 }
3204
3205 class wxPyGridCellRenderer : public wxGridCellRenderer
3206 {
3207 public:
3208 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3209
3210 // Implement Python callback aware virtual methods
3211 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3212 wxDC& dc, const wxRect& rect,
3213 int row, int col, bool isSelected) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3216 PyObject* go = wxPyMake_wxObject(&grid,false);
3217 PyObject* dco = wxPyMake_wxObject(&dc,false);
3218 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3219 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3220
3221 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3222 row, col, isSelected));
3223 Py_DECREF(go);
3224 Py_DECREF(ao);
3225 Py_DECREF(dco);
3226 Py_DECREF(ro);
3227 }
3228 wxPyEndBlockThreads(blocked);
3229 }
3230
3231 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3232 int row, int col) {
3233 wxSize rval;
3234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3235 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3236 PyObject* ro;
3237 wxSize* ptr;
3238 PyObject* go = wxPyMake_wxObject(&grid,false);
3239 PyObject* dco = wxPyMake_wxObject(&dc,false);
3240 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3241
3242 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3243 go, ao, dco,
3244 row, col));
3245 Py_DECREF(go);
3246 Py_DECREF(ao);
3247 Py_DECREF(dco);
3248
3249 if (ro) {
3250 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3251 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3252 rval = *ptr;
3253 }
3254 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3255 PyObject* o1 = PySequence_GetItem(ro, 0);
3256 PyObject* o2 = PySequence_GetItem(ro, 1);
3257 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3258 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3259 else
3260 PyErr_SetString(PyExc_TypeError, errmsg);
3261 Py_DECREF(o1);
3262 Py_DECREF(o2);
3263 }
3264 else {
3265 PyErr_SetString(PyExc_TypeError, errmsg);
3266 }
3267 Py_DECREF(ro);
3268 }
3269 }
3270 wxPyEndBlockThreads(blocked);
3271 return rval;
3272 }
3273
3274
3275 wxGridCellRenderer *Clone() const {
3276 wxGridCellRenderer* rval = NULL;
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3279 PyObject* ro;
3280 wxGridCellRenderer* ptr;
3281 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3282 if (ro) {
3283 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3284 rval = ptr;
3285 Py_DECREF(ro);
3286 }
3287 }
3288 wxPyEndBlockThreads(blocked);
3289 return rval;
3290 }
3291
3292 DEC_PYCALLBACK__STRING(SetParameters);
3293
3294 PYPRIVATE;
3295 };
3296
3297 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3298
3299
3300
3301 #include <limits.h>
3302 #ifndef LLONG_MIN
3303 # define LLONG_MIN LONG_LONG_MIN
3304 #endif
3305 #ifndef LLONG_MAX
3306 # define LLONG_MAX LONG_LONG_MAX
3307 #endif
3308 #ifndef ULLONG_MAX
3309 # define ULLONG_MAX ULONG_LONG_MAX
3310 #endif
3311
3312
3313 SWIGINTERN int
3314 SWIG_AsVal_long (PyObject* obj, long* val)
3315 {
3316 if (PyNumber_Check(obj)) {
3317 if (val) *val = PyInt_AsLong(obj);
3318 return SWIG_OK;
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsVal_int (PyObject * obj, int *val)
3326 {
3327 long v;
3328 int res = SWIG_AsVal_long (obj, &v);
3329 if (SWIG_IsOK(res)) {
3330 if ((v < INT_MIN || v > INT_MAX)) {
3331 return SWIG_OverflowError;
3332 } else {
3333 if (val) *val = static_cast< int >(v);
3334 }
3335 }
3336 return res;
3337 }
3338
3339
3340 SWIGINTERN int
3341 SWIG_AsVal_bool (PyObject *obj, bool *val)
3342 {
3343 if (obj == Py_True) {
3344 if (val) *val = true;
3345 return SWIG_OK;
3346 } else if (obj == Py_False) {
3347 if (val) *val = false;
3348 return SWIG_OK;
3349 } else {
3350 long v = 0;
3351 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3352 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3353 return res;
3354 }
3355 }
3356
3357
3358 class wxPyGridCellEditor : public wxGridCellEditor
3359 {
3360 public:
3361 wxPyGridCellEditor() : wxGridCellEditor() {}
3362
3363 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3364 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3365 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3366 PyObject* po = wxPyMake_wxObject(parent,false);
3367 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3368
3369 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3370 Py_DECREF(po);
3371 Py_DECREF(eo);
3372 }
3373 wxPyEndBlockThreads(blocked);
3374 }
3375
3376
3377 void BeginEdit(int row, int col, wxGrid* grid) {
3378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3379 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3380 PyObject* go = wxPyMake_wxObject(grid,false);
3381 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3382 Py_DECREF(go);
3383 }
3384 wxPyEndBlockThreads(blocked);
3385 }
3386
3387
3388 bool EndEdit(int row, int col, wxGrid* grid) {
3389 bool rv = false;
3390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3391 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3392 PyObject* go = wxPyMake_wxObject(grid,false);
3393 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3394 Py_DECREF(go);
3395 }
3396 wxPyEndBlockThreads(blocked);
3397 return rv;
3398 }
3399
3400
3401 wxGridCellEditor* Clone() const {
3402 wxGridCellEditor* rval = NULL;
3403 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3404 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3405 PyObject* ro;
3406 wxGridCellEditor* ptr;
3407 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3408 if (ro) {
3409 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3410 rval = ptr;
3411 Py_DECREF(ro);
3412 }
3413 }
3414 wxPyEndBlockThreads(blocked);
3415 return rval;
3416 }
3417
3418
3419 void Show(bool show, wxGridCellAttr *attr) {
3420 bool found;
3421 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3422 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3423 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3424 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3425 Py_DECREF(ao);
3426 }
3427 wxPyEndBlockThreads(blocked);
3428 if (! found)
3429 wxGridCellEditor::Show(show, attr);
3430 }
3431
3432
3433 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3434 bool found;
3435 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3436 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3437 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3438 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3439
3440 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3441
3442 Py_DECREF(ro);
3443 Py_DECREF(ao);
3444 }
3445 wxPyEndBlockThreads(blocked);
3446 if (! found)
3447 wxGridCellEditor::PaintBackground(rectCell, attr);
3448 }
3449
3450
3451 DEC_PYCALLBACK___pure(Reset);
3452 DEC_PYCALLBACK__constany(SetSize, wxRect);
3453 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3454 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3455 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3456 DEC_PYCALLBACK__(StartingClick);
3457 DEC_PYCALLBACK__(Destroy);
3458 DEC_PYCALLBACK__STRING(SetParameters);
3459 DEC_PYCALLBACK_STRING__constpure(GetValue);
3460
3461 PYPRIVATE;
3462 };
3463
3464
3465 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3466 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3467 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3468 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3469 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3470 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3471 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3472 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3473 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3474
3475
3476 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3477 if (!self->GetClientObject())
3478 self->SetClientObject(new wxPyOORClientData(_self));
3479 }
3480 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *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 bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3741 wxGridCellCoords temp, *obj = &temp;
3742 if ( other == Py_None ) return false;
3743 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3744 PyErr_Clear();
3745 return false;
3746 }
3747 return self->operator==(*obj);
3748 }
3749 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3750 wxGridCellCoords temp, *obj = &temp;
3751 if ( other == Py_None ) return true;
3752 if ( ! wxGridCellCoords_helper(other, &obj)) {
3753 PyErr_Clear();
3754 return true;
3755 }
3756 return self->operator!=(*obj);
3757 }
3758 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3759 PyObject* tup = PyTuple_New(2);
3760 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3761 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3762 return tup;
3763 }
3764
3765 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3766
3767 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3768 wxGridCellCoords rv;
3769 self->XYToCell(x, y, rv);
3770 return rv;
3771 }
3772 #ifdef __cplusplus
3773 extern "C" {
3774 #endif
3775 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3776 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3777 return 1;
3778 }
3779
3780
3781 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3782 PyObject *pyobj = 0;
3783
3784 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3785 return pyobj;
3786 }
3787
3788
3789 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3790 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3791 return 1;
3792 }
3793
3794
3795 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3796 PyObject *pyobj = 0;
3797
3798 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3799 return pyobj;
3800 }
3801
3802
3803 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj = 0;
3805 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3806 PyObject *arg2 = (PyObject *) 0 ;
3807 void *argp1 = 0 ;
3808 int res1 = 0 ;
3809 PyObject * obj0 = 0 ;
3810 PyObject * obj1 = 0 ;
3811 char * kwnames[] = {
3812 (char *) "self",(char *) "_self", NULL
3813 };
3814
3815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3817 if (!SWIG_IsOK(res1)) {
3818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3819 }
3820 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3821 arg2 = obj1;
3822 {
3823 PyThreadState* __tstate = wxPyBeginAllowThreads();
3824 wxGridCellWorker__setOORInfo(arg1,arg2);
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 resultobj = SWIG_Py_Void();
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3836 PyObject *resultobj = 0;
3837 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3838 void *argp1 = 0 ;
3839 int res1 = 0 ;
3840 PyObject *swig_obj[1] ;
3841
3842 if (!args) SWIG_fail;
3843 swig_obj[0] = args;
3844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3845 if (!SWIG_IsOK(res1)) {
3846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3847 }
3848 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3849 {
3850 PyThreadState* __tstate = wxPyBeginAllowThreads();
3851 delete_wxGridCellWorker(arg1);
3852
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 resultobj = SWIG_Py_Void();
3857 return resultobj;
3858 fail:
3859 return NULL;
3860 }
3861
3862
3863 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3864 PyObject *resultobj = 0;
3865 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3866 wxString *arg2 = 0 ;
3867 void *argp1 = 0 ;
3868 int res1 = 0 ;
3869 bool temp2 = false ;
3870 PyObject * obj0 = 0 ;
3871 PyObject * obj1 = 0 ;
3872 char * kwnames[] = {
3873 (char *) "self",(char *) "params", NULL
3874 };
3875
3876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3878 if (!SWIG_IsOK(res1)) {
3879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3880 }
3881 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3882 {
3883 arg2 = wxString_in_helper(obj1);
3884 if (arg2 == NULL) SWIG_fail;
3885 temp2 = true;
3886 }
3887 {
3888 PyThreadState* __tstate = wxPyBeginAllowThreads();
3889 (arg1)->SetParameters((wxString const &)*arg2);
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 resultobj = SWIG_Py_Void();
3894 {
3895 if (temp2)
3896 delete arg2;
3897 }
3898 return resultobj;
3899 fail:
3900 {
3901 if (temp2)
3902 delete arg2;
3903 }
3904 return NULL;
3905 }
3906
3907
3908 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3909 PyObject *resultobj = 0;
3910 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3911 void *argp1 = 0 ;
3912 int res1 = 0 ;
3913 PyObject *swig_obj[1] ;
3914
3915 if (!args) SWIG_fail;
3916 swig_obj[0] = args;
3917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3918 if (!SWIG_IsOK(res1)) {
3919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3920 }
3921 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3922 {
3923 PyThreadState* __tstate = wxPyBeginAllowThreads();
3924 (arg1)->IncRef();
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 resultobj = SWIG_Py_Void();
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3936 PyObject *resultobj = 0;
3937 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3938 void *argp1 = 0 ;
3939 int res1 = 0 ;
3940 PyObject *swig_obj[1] ;
3941
3942 if (!args) SWIG_fail;
3943 swig_obj[0] = args;
3944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3945 if (!SWIG_IsOK(res1)) {
3946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3947 }
3948 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 (arg1)->DecRef();
3952 wxPyEndAllowThreads(__tstate);
3953 if (PyErr_Occurred()) SWIG_fail;
3954 }
3955 resultobj = SWIG_Py_Void();
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3963 PyObject *obj;
3964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3965 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3966 return SWIG_Py_Void();
3967 }
3968
3969 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3970 PyObject *obj;
3971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3972 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3973 return SWIG_Py_Void();
3974 }
3975
3976 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3977 PyObject *resultobj = 0;
3978 wxPyGridCellRenderer *result = 0 ;
3979
3980 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3981 {
3982 PyThreadState* __tstate = wxPyBeginAllowThreads();
3983 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3984 wxPyEndAllowThreads(__tstate);
3985 if (PyErr_Occurred()) SWIG_fail;
3986 }
3987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj = 0;
3996 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3997 PyObject *arg2 = (PyObject *) 0 ;
3998 PyObject *arg3 = (PyObject *) 0 ;
3999 void *argp1 = 0 ;
4000 int res1 = 0 ;
4001 PyObject * obj0 = 0 ;
4002 PyObject * obj1 = 0 ;
4003 PyObject * obj2 = 0 ;
4004 char * kwnames[] = {
4005 (char *) "self",(char *) "self",(char *) "_class", NULL
4006 };
4007
4008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4010 if (!SWIG_IsOK(res1)) {
4011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4012 }
4013 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4014 arg2 = obj1;
4015 arg3 = obj2;
4016 {
4017 PyThreadState* __tstate = wxPyBeginAllowThreads();
4018 (arg1)->_setCallbackInfo(arg2,arg3);
4019 wxPyEndAllowThreads(__tstate);
4020 if (PyErr_Occurred()) SWIG_fail;
4021 }
4022 resultobj = SWIG_Py_Void();
4023 return resultobj;
4024 fail:
4025 return NULL;
4026 }
4027
4028
4029 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj = 0;
4031 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4032 wxString *arg2 = 0 ;
4033 void *argp1 = 0 ;
4034 int res1 = 0 ;
4035 bool temp2 = false ;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 char * kwnames[] = {
4039 (char *) "self",(char *) "params", NULL
4040 };
4041
4042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4044 if (!SWIG_IsOK(res1)) {
4045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4046 }
4047 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4048 {
4049 arg2 = wxString_in_helper(obj1);
4050 if (arg2 == NULL) SWIG_fail;
4051 temp2 = true;
4052 }
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 (arg1)->SetParameters((wxString const &)*arg2);
4056 wxPyEndAllowThreads(__tstate);
4057 if (PyErr_Occurred()) SWIG_fail;
4058 }
4059 resultobj = SWIG_Py_Void();
4060 {
4061 if (temp2)
4062 delete arg2;
4063 }
4064 return resultobj;
4065 fail:
4066 {
4067 if (temp2)
4068 delete arg2;
4069 }
4070 return NULL;
4071 }
4072
4073
4074 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4075 PyObject *obj;
4076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4077 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4078 return SWIG_Py_Void();
4079 }
4080
4081 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4082 return SWIG_Python_InitShadowInstance(args);
4083 }
4084
4085 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4086 PyObject *resultobj = 0;
4087 wxGridCellStringRenderer *result = 0 ;
4088
4089 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4093 wxPyEndAllowThreads(__tstate);
4094 if (PyErr_Occurred()) SWIG_fail;
4095 }
4096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4097 return resultobj;
4098 fail:
4099 return NULL;
4100 }
4101
4102
4103 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4104 PyObject *obj;
4105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4106 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4107 return SWIG_Py_Void();
4108 }
4109
4110 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4111 return SWIG_Python_InitShadowInstance(args);
4112 }
4113
4114 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4115 PyObject *resultobj = 0;
4116 wxGridCellNumberRenderer *result = 0 ;
4117
4118 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4119 {
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4133 PyObject *obj;
4134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4135 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4136 return SWIG_Py_Void();
4137 }
4138
4139 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4140 return SWIG_Python_InitShadowInstance(args);
4141 }
4142
4143 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4144 PyObject *resultobj = 0;
4145 int arg1 = (int) -1 ;
4146 int arg2 = (int) -1 ;
4147 wxGridCellFloatRenderer *result = 0 ;
4148 int val1 ;
4149 int ecode1 = 0 ;
4150 int val2 ;
4151 int ecode2 = 0 ;
4152 PyObject * obj0 = 0 ;
4153 PyObject * obj1 = 0 ;
4154 char * kwnames[] = {
4155 (char *) "width",(char *) "precision", NULL
4156 };
4157
4158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4159 if (obj0) {
4160 ecode1 = SWIG_AsVal_int(obj0, &val1);
4161 if (!SWIG_IsOK(ecode1)) {
4162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4163 }
4164 arg1 = static_cast< int >(val1);
4165 }
4166 if (obj1) {
4167 ecode2 = SWIG_AsVal_int(obj1, &val2);
4168 if (!SWIG_IsOK(ecode2)) {
4169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4170 }
4171 arg2 = static_cast< int >(val2);
4172 }
4173 {
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4187 PyObject *resultobj = 0;
4188 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4189 int result;
4190 void *argp1 = 0 ;
4191 int res1 = 0 ;
4192 PyObject *swig_obj[1] ;
4193
4194 if (!args) SWIG_fail;
4195 swig_obj[0] = args;
4196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4197 if (!SWIG_IsOK(res1)) {
4198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4199 }
4200 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4201 {
4202 PyThreadState* __tstate = wxPyBeginAllowThreads();
4203 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4204 wxPyEndAllowThreads(__tstate);
4205 if (PyErr_Occurred()) SWIG_fail;
4206 }
4207 resultobj = SWIG_From_int(static_cast< int >(result));
4208 return resultobj;
4209 fail:
4210 return NULL;
4211 }
4212
4213
4214 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4215 PyObject *resultobj = 0;
4216 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4217 int arg2 ;
4218 void *argp1 = 0 ;
4219 int res1 = 0 ;
4220 int val2 ;
4221 int ecode2 = 0 ;
4222 PyObject * obj0 = 0 ;
4223 PyObject * obj1 = 0 ;
4224 char * kwnames[] = {
4225 (char *) "self",(char *) "width", NULL
4226 };
4227
4228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4230 if (!SWIG_IsOK(res1)) {
4231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4232 }
4233 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4234 ecode2 = SWIG_AsVal_int(obj1, &val2);
4235 if (!SWIG_IsOK(ecode2)) {
4236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4237 }
4238 arg2 = static_cast< int >(val2);
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 (arg1)->SetWidth(arg2);
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 resultobj = SWIG_Py_Void();
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4253 PyObject *resultobj = 0;
4254 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4255 int result;
4256 void *argp1 = 0 ;
4257 int res1 = 0 ;
4258 PyObject *swig_obj[1] ;
4259
4260 if (!args) SWIG_fail;
4261 swig_obj[0] = args;
4262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4263 if (!SWIG_IsOK(res1)) {
4264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4265 }
4266 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4267 {
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 resultobj = SWIG_From_int(static_cast< int >(result));
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj = 0;
4282 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4283 int arg2 ;
4284 void *argp1 = 0 ;
4285 int res1 = 0 ;
4286 int val2 ;
4287 int ecode2 = 0 ;
4288 PyObject * obj0 = 0 ;
4289 PyObject * obj1 = 0 ;
4290 char * kwnames[] = {
4291 (char *) "self",(char *) "precision", NULL
4292 };
4293
4294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4296 if (!SWIG_IsOK(res1)) {
4297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4298 }
4299 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4300 ecode2 = SWIG_AsVal_int(obj1, &val2);
4301 if (!SWIG_IsOK(ecode2)) {
4302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4303 }
4304 arg2 = static_cast< int >(val2);
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 (arg1)->SetPrecision(arg2);
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 resultobj = SWIG_Py_Void();
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4319 PyObject *obj;
4320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4321 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4322 return SWIG_Py_Void();
4323 }
4324
4325 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4326 return SWIG_Python_InitShadowInstance(args);
4327 }
4328
4329 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330 PyObject *resultobj = 0;
4331 wxGridCellBoolRenderer *result = 0 ;
4332
4333 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4334 {
4335 PyThreadState* __tstate = wxPyBeginAllowThreads();
4336 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4337 wxPyEndAllowThreads(__tstate);
4338 if (PyErr_Occurred()) SWIG_fail;
4339 }
4340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4341 return resultobj;
4342 fail:
4343 return NULL;
4344 }
4345
4346
4347 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4348 PyObject *obj;
4349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4350 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4351 return SWIG_Py_Void();
4352 }
4353
4354 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4355 return SWIG_Python_InitShadowInstance(args);
4356 }
4357
4358 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4359 PyObject *resultobj = 0;
4360 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4361 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4362 wxGridCellDateTimeRenderer *result = 0 ;
4363 PyObject * obj0 = 0 ;
4364 PyObject * obj1 = 0 ;
4365 char * kwnames[] = {
4366 (char *) "outformat",(char *) "informat", NULL
4367 };
4368
4369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4370 if (obj0) {
4371 {
4372 wxString* sptr = wxString_in_helper(obj0);
4373 if (sptr == NULL) SWIG_fail;
4374 arg1 = *sptr;
4375 delete sptr;
4376 }
4377 }
4378 if (obj1) {
4379 {
4380 wxString* sptr = wxString_in_helper(obj1);
4381 if (sptr == NULL) SWIG_fail;
4382 arg2 = *sptr;
4383 delete sptr;
4384 }
4385 }
4386 {
4387 PyThreadState* __tstate = wxPyBeginAllowThreads();
4388 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4389 wxPyEndAllowThreads(__tstate);
4390 if (PyErr_Occurred()) SWIG_fail;
4391 }
4392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4393 return resultobj;
4394 fail:
4395 return NULL;
4396 }
4397
4398
4399 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400 PyObject *obj;
4401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4402 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4403 return SWIG_Py_Void();
4404 }
4405
4406 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407 return SWIG_Python_InitShadowInstance(args);
4408 }
4409
4410 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj = 0;
4412 wxString const &arg1_defvalue = wxPyEmptyString ;
4413 wxString *arg1 = (wxString *) &arg1_defvalue ;
4414 wxGridCellEnumRenderer *result = 0 ;
4415 bool temp1 = false ;
4416 PyObject * obj0 = 0 ;
4417 char * kwnames[] = {
4418 (char *) "choices", NULL
4419 };
4420
4421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4422 if (obj0) {
4423 {
4424 arg1 = wxString_in_helper(obj0);
4425 if (arg1 == NULL) SWIG_fail;
4426 temp1 = true;
4427 }
4428 }
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4436 {
4437 if (temp1)
4438 delete arg1;
4439 }
4440 return resultobj;
4441 fail:
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 return NULL;
4447 }
4448
4449
4450 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4451 PyObject *obj;
4452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4453 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4454 return SWIG_Py_Void();
4455 }
4456
4457 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 return SWIG_Python_InitShadowInstance(args);
4459 }
4460
4461 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 wxGridCellAutoWrapStringRenderer *result = 0 ;
4464
4465 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4466 {
4467 PyThreadState* __tstate = wxPyBeginAllowThreads();
4468 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4469 wxPyEndAllowThreads(__tstate);
4470 if (PyErr_Occurred()) SWIG_fail;
4471 }
4472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4480 PyObject *obj;
4481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4482 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4483 return SWIG_Py_Void();
4484 }
4485
4486 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 return SWIG_Python_InitShadowInstance(args);
4488 }
4489
4490 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4493 bool result;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4503 }
4504 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4505 {
4506 PyThreadState* __tstate = wxPyBeginAllowThreads();
4507 result = (bool)(arg1)->IsCreated();
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 {
4512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4513 }
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521 PyObject *resultobj = 0;
4522 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4523 wxControl *result = 0 ;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 PyObject *swig_obj[1] ;
4527
4528 if (!args) SWIG_fail;
4529 swig_obj[0] = args;
4530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4531 if (!SWIG_IsOK(res1)) {
4532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4533 }
4534 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = (wxControl *)(arg1)->GetControl();
4538 wxPyEndAllowThreads(__tstate);
4539 if (PyErr_Occurred()) SWIG_fail;
4540 }
4541 {
4542 resultobj = wxPyMake_wxObject(result, 0);
4543 }
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4551 PyObject *resultobj = 0;
4552 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4553 wxControl *arg2 = (wxControl *) 0 ;
4554 void *argp1 = 0 ;
4555 int res1 = 0 ;
4556 void *argp2 = 0 ;
4557 int res2 = 0 ;
4558 PyObject * obj0 = 0 ;
4559 PyObject * obj1 = 0 ;
4560 char * kwnames[] = {
4561 (char *) "self",(char *) "control", NULL
4562 };
4563
4564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4566 if (!SWIG_IsOK(res1)) {
4567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4568 }
4569 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4571 if (!SWIG_IsOK(res2)) {
4572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4573 }
4574 arg2 = reinterpret_cast< wxControl * >(argp2);
4575 {
4576 PyThreadState* __tstate = wxPyBeginAllowThreads();
4577 (arg1)->SetControl(arg2);
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 resultobj = SWIG_Py_Void();
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 PyObject *resultobj = 0;
4590 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4591 wxGridCellAttr *result = 0 ;
4592 void *argp1 = 0 ;
4593 int res1 = 0 ;
4594 PyObject *swig_obj[1] ;
4595
4596 if (!args) SWIG_fail;
4597 swig_obj[0] = args;
4598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4599 if (!SWIG_IsOK(res1)) {
4600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4601 }
4602 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4606 wxPyEndAllowThreads(__tstate);
4607 if (PyErr_Occurred()) SWIG_fail;
4608 }
4609 {
4610 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4611 }
4612 return resultobj;
4613 fail:
4614 return NULL;
4615 }
4616
4617
4618 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4619 PyObject *resultobj = 0;
4620 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4621 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4622 void *argp1 = 0 ;
4623 int res1 = 0 ;
4624 void *argp2 = 0 ;
4625 int res2 = 0 ;
4626 PyObject * obj0 = 0 ;
4627 PyObject * obj1 = 0 ;
4628 char * kwnames[] = {
4629 (char *) "self",(char *) "attr", NULL
4630 };
4631
4632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4636 }
4637 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4639 if (!SWIG_IsOK(res2)) {
4640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4641 }
4642 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 (arg1)->SetCellAttr(arg2);
4646 wxPyEndAllowThreads(__tstate);
4647 if (PyErr_Occurred()) SWIG_fail;
4648 }
4649 resultobj = SWIG_Py_Void();
4650 return resultobj;
4651 fail:
4652 return NULL;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4657 PyObject *resultobj = 0;
4658 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4659 wxWindow *arg2 = (wxWindow *) 0 ;
4660 int arg3 ;
4661 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 void *argp2 = 0 ;
4665 int res2 = 0 ;
4666 int val3 ;
4667 int ecode3 = 0 ;
4668 void *argp4 = 0 ;
4669 int res4 = 0 ;
4670 PyObject * obj0 = 0 ;
4671 PyObject * obj1 = 0 ;
4672 PyObject * obj2 = 0 ;
4673 PyObject * obj3 = 0 ;
4674 char * kwnames[] = {
4675 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4676 };
4677
4678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4680 if (!SWIG_IsOK(res1)) {
4681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4682 }
4683 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4685 if (!SWIG_IsOK(res2)) {
4686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4687 }
4688 arg2 = reinterpret_cast< wxWindow * >(argp2);
4689 ecode3 = SWIG_AsVal_int(obj2, &val3);
4690 if (!SWIG_IsOK(ecode3)) {
4691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4692 }
4693 arg3 = static_cast< int >(val3);
4694 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4695 if (!SWIG_IsOK(res4)) {
4696 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4697 }
4698 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 (arg1)->Create(arg2,arg3,arg4);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_Py_Void();
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj = 0;
4714 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4715 int arg2 ;
4716 int arg3 ;
4717 wxGrid *arg4 = (wxGrid *) 0 ;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 int val2 ;
4721 int ecode2 = 0 ;
4722 int val3 ;
4723 int ecode3 = 0 ;
4724 void *argp4 = 0 ;
4725 int res4 = 0 ;
4726 PyObject * obj0 = 0 ;
4727 PyObject * obj1 = 0 ;
4728 PyObject * obj2 = 0 ;
4729 PyObject * obj3 = 0 ;
4730 char * kwnames[] = {
4731 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4732 };
4733
4734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4736 if (!SWIG_IsOK(res1)) {
4737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4738 }
4739 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4740 ecode2 = SWIG_AsVal_int(obj1, &val2);
4741 if (!SWIG_IsOK(ecode2)) {
4742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4743 }
4744 arg2 = static_cast< int >(val2);
4745 ecode3 = SWIG_AsVal_int(obj2, &val3);
4746 if (!SWIG_IsOK(ecode3)) {
4747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4748 }
4749 arg3 = static_cast< int >(val3);
4750 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4751 if (!SWIG_IsOK(res4)) {
4752 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4753 }
4754 arg4 = reinterpret_cast< wxGrid * >(argp4);
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 (arg1)->BeginEdit(arg2,arg3,arg4);
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 resultobj = SWIG_Py_Void();
4762 return resultobj;
4763 fail:
4764 return NULL;
4765 }
4766
4767
4768 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4769 PyObject *resultobj = 0;
4770 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4771 int arg2 ;
4772 int arg3 ;
4773 wxGrid *arg4 = (wxGrid *) 0 ;
4774 bool result;
4775 void *argp1 = 0 ;
4776 int res1 = 0 ;
4777 int val2 ;
4778 int ecode2 = 0 ;
4779 int val3 ;
4780 int ecode3 = 0 ;
4781 void *argp4 = 0 ;
4782 int res4 = 0 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 PyObject * obj2 = 0 ;
4786 PyObject * obj3 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4795 }
4796 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4797 ecode2 = SWIG_AsVal_int(obj1, &val2);
4798 if (!SWIG_IsOK(ecode2)) {
4799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4800 }
4801 arg2 = static_cast< int >(val2);
4802 ecode3 = SWIG_AsVal_int(obj2, &val3);
4803 if (!SWIG_IsOK(ecode3)) {
4804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4805 }
4806 arg3 = static_cast< int >(val3);
4807 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4808 if (!SWIG_IsOK(res4)) {
4809 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4810 }
4811 arg4 = reinterpret_cast< wxGrid * >(argp4);
4812 {
4813 PyThreadState* __tstate = wxPyBeginAllowThreads();
4814 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4815 wxPyEndAllowThreads(__tstate);
4816 if (PyErr_Occurred()) SWIG_fail;
4817 }
4818 {
4819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4820 }
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4828 PyObject *resultobj = 0;
4829 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4830 void *argp1 = 0 ;
4831 int res1 = 0 ;
4832 PyObject *swig_obj[1] ;
4833
4834 if (!args) SWIG_fail;
4835 swig_obj[0] = args;
4836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4837 if (!SWIG_IsOK(res1)) {
4838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4839 }
4840 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->Reset();
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4855 PyObject *resultobj = 0;
4856 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4857 wxGridCellEditor *result = 0 ;
4858 void *argp1 = 0 ;
4859 int res1 = 0 ;
4860 PyObject *swig_obj[1] ;
4861
4862 if (!args) SWIG_fail;
4863 swig_obj[0] = args;
4864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4865 if (!SWIG_IsOK(res1)) {
4866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4867 }
4868 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 {
4876 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4877 }
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj = 0;
4886 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4887 wxRect *arg2 = 0 ;
4888 void *argp1 = 0 ;
4889 int res1 = 0 ;
4890 wxRect temp2 ;
4891 PyObject * obj0 = 0 ;
4892 PyObject * obj1 = 0 ;
4893 char * kwnames[] = {
4894 (char *) "self",(char *) "rect", NULL
4895 };
4896
4897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4899 if (!SWIG_IsOK(res1)) {
4900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4901 }
4902 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4903 {
4904 arg2 = &temp2;
4905 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4906 }
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 (arg1)->SetSize((wxRect const &)*arg2);
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_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4921 PyObject *resultobj = 0;
4922 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4923 bool arg2 ;
4924 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4925 void *argp1 = 0 ;
4926 int res1 = 0 ;
4927 bool val2 ;
4928 int ecode2 = 0 ;
4929 void *argp3 = 0 ;
4930 int res3 = 0 ;
4931 PyObject * obj0 = 0 ;
4932 PyObject * obj1 = 0 ;
4933 PyObject * obj2 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "self",(char *) "show",(char *) "attr", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4940 if (!SWIG_IsOK(res1)) {
4941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4942 }
4943 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4945 if (!SWIG_IsOK(ecode2)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4947 }
4948 arg2 = static_cast< bool >(val2);
4949 if (obj2) {
4950 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4951 if (!SWIG_IsOK(res3)) {
4952 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4953 }
4954 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4955 }
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->Show(arg2,arg3);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj = 0;
4971 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4972 wxRect *arg2 = 0 ;
4973 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4974 void *argp1 = 0 ;
4975 int res1 = 0 ;
4976 wxRect temp2 ;
4977 void *argp3 = 0 ;
4978 int res3 = 0 ;
4979 PyObject * obj0 = 0 ;
4980 PyObject * obj1 = 0 ;
4981 PyObject * obj2 = 0 ;
4982 char * kwnames[] = {
4983 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4984 };
4985
4986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4988 if (!SWIG_IsOK(res1)) {
4989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4990 }
4991 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4992 {
4993 arg2 = &temp2;
4994 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4995 }
4996 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4997 if (!SWIG_IsOK(res3)) {
4998 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4999 }
5000 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5001 {
5002 PyThreadState* __tstate = wxPyBeginAllowThreads();
5003 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5004 wxPyEndAllowThreads(__tstate);
5005 if (PyErr_Occurred()) SWIG_fail;
5006 }
5007 resultobj = SWIG_Py_Void();
5008 return resultobj;
5009 fail:
5010 return NULL;
5011 }
5012
5013
5014 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5015 PyObject *resultobj = 0;
5016 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5017 wxKeyEvent *arg2 = 0 ;
5018 bool result;
5019 void *argp1 = 0 ;
5020 int res1 = 0 ;
5021 void *argp2 = 0 ;
5022 int res2 = 0 ;
5023 PyObject * obj0 = 0 ;
5024 PyObject * obj1 = 0 ;
5025 char * kwnames[] = {
5026 (char *) "self",(char *) "event", NULL
5027 };
5028
5029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5031 if (!SWIG_IsOK(res1)) {
5032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5033 }
5034 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5035 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5036 if (!SWIG_IsOK(res2)) {
5037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5038 }
5039 if (!argp2) {
5040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5041 }
5042 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj = 0;
5060 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5061 wxKeyEvent *arg2 = 0 ;
5062 void *argp1 = 0 ;
5063 int res1 = 0 ;
5064 void *argp2 = 0 ;
5065 int res2 = 0 ;
5066 PyObject * obj0 = 0 ;
5067 PyObject * obj1 = 0 ;
5068 char * kwnames[] = {
5069 (char *) "self",(char *) "event", NULL
5070 };
5071
5072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5074 if (!SWIG_IsOK(res1)) {
5075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5076 }
5077 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5079 if (!SWIG_IsOK(res2)) {
5080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5081 }
5082 if (!argp2) {
5083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5084 }
5085 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5086 {
5087 PyThreadState* __tstate = wxPyBeginAllowThreads();
5088 (arg1)->StartingKey(*arg2);
5089 wxPyEndAllowThreads(__tstate);
5090 if (PyErr_Occurred()) SWIG_fail;
5091 }
5092 resultobj = SWIG_Py_Void();
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5100 PyObject *resultobj = 0;
5101 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5102 void *argp1 = 0 ;
5103 int res1 = 0 ;
5104 PyObject *swig_obj[1] ;
5105
5106 if (!args) SWIG_fail;
5107 swig_obj[0] = args;
5108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5109 if (!SWIG_IsOK(res1)) {
5110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5111 }
5112 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5113 {
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 (arg1)->StartingClick();
5116 wxPyEndAllowThreads(__tstate);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5129 wxKeyEvent *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 void *argp2 = 0 ;
5133 int res2 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "event", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5144 }
5145 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5147 if (!SWIG_IsOK(res2)) {
5148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5149 }
5150 if (!argp2) {
5151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5152 }
5153 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 (arg1)->HandleReturn(*arg2);
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 resultobj = SWIG_Py_Void();
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5168 PyObject *resultobj = 0;
5169 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5170 void *argp1 = 0 ;
5171 int res1 = 0 ;
5172 PyObject *swig_obj[1] ;
5173
5174 if (!args) SWIG_fail;
5175 swig_obj[0] = args;
5176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5179 }
5180 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 (arg1)->Destroy();
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_Py_Void();
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5195 PyObject *obj;
5196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5197 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5198 return SWIG_Py_Void();
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxPyGridCellEditor *result = 0 ;
5204
5205 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj = 0;
5221 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5222 PyObject *arg2 = (PyObject *) 0 ;
5223 PyObject *arg3 = (PyObject *) 0 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 PyObject * obj1 = 0 ;
5228 PyObject * obj2 = 0 ;
5229 char * kwnames[] = {
5230 (char *) "self",(char *) "self",(char *) "_class", NULL
5231 };
5232
5233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5237 }
5238 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5239 arg2 = obj1;
5240 arg3 = obj2;
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 (arg1)->_setCallbackInfo(arg2,arg3);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = 0;
5256 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5257 wxString *arg2 = 0 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 bool temp2 = false ;
5261 PyObject * obj0 = 0 ;
5262 PyObject * obj1 = 0 ;
5263 char * kwnames[] = {
5264 (char *) "self",(char *) "params", NULL
5265 };
5266
5267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5269 if (!SWIG_IsOK(res1)) {
5270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5271 }
5272 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5273 {
5274 arg2 = wxString_in_helper(obj1);
5275 if (arg2 == NULL) SWIG_fail;
5276 temp2 = true;
5277 }
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 (arg1)->SetParameters((wxString const &)*arg2);
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 {
5286 if (temp2)
5287 delete arg2;
5288 }
5289 return resultobj;
5290 fail:
5291 {
5292 if (temp2)
5293 delete arg2;
5294 }
5295 return NULL;
5296 }
5297
5298
5299 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5300 PyObject *obj;
5301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5302 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5303 return SWIG_Py_Void();
5304 }
5305
5306 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5307 return SWIG_Python_InitShadowInstance(args);
5308 }
5309
5310 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5311 PyObject *resultobj = 0;
5312 wxGridCellTextEditor *result = 0 ;
5313
5314 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5315 {
5316 PyThreadState* __tstate = wxPyBeginAllowThreads();
5317 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5318 wxPyEndAllowThreads(__tstate);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5329 PyObject *resultobj = 0;
5330 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5331 wxString result;
5332 void *argp1 = 0 ;
5333 int res1 = 0 ;
5334 PyObject *swig_obj[1] ;
5335
5336 if (!args) SWIG_fail;
5337 swig_obj[0] = args;
5338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5339 if (!SWIG_IsOK(res1)) {
5340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5341 }
5342 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 result = (arg1)->GetValue();
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 {
5350 #if wxUSE_UNICODE
5351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5352 #else
5353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5354 #endif
5355 }
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5363 PyObject *obj;
5364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5366 return SWIG_Py_Void();
5367 }
5368
5369 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5370 return SWIG_Python_InitShadowInstance(args);
5371 }
5372
5373 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj = 0;
5375 int arg1 = (int) -1 ;
5376 int arg2 = (int) -1 ;
5377 wxGridCellNumberEditor *result = 0 ;
5378 int val1 ;
5379 int ecode1 = 0 ;
5380 int val2 ;
5381 int ecode2 = 0 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char * kwnames[] = {
5385 (char *) "min",(char *) "max", NULL
5386 };
5387
5388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5389 if (obj0) {
5390 ecode1 = SWIG_AsVal_int(obj0, &val1);
5391 if (!SWIG_IsOK(ecode1)) {
5392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5393 }
5394 arg1 = static_cast< int >(val1);
5395 }
5396 if (obj1) {
5397 ecode2 = SWIG_AsVal_int(obj1, &val2);
5398 if (!SWIG_IsOK(ecode2)) {
5399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5400 }
5401 arg2 = static_cast< int >(val2);
5402 }
5403 {
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *obj;
5418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5419 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5420 return SWIG_Py_Void();
5421 }
5422
5423 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 return SWIG_Python_InitShadowInstance(args);
5425 }
5426
5427 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5428 PyObject *resultobj = 0;
5429 int arg1 = (int) -1 ;
5430 int arg2 = (int) -1 ;
5431 wxGridCellFloatEditor *result = 0 ;
5432 int val1 ;
5433 int ecode1 = 0 ;
5434 int val2 ;
5435 int ecode2 = 0 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "width",(char *) "precision", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5443 if (obj0) {
5444 ecode1 = SWIG_AsVal_int(obj0, &val1);
5445 if (!SWIG_IsOK(ecode1)) {
5446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5447 }
5448 arg1 = static_cast< int >(val1);
5449 }
5450 if (obj1) {
5451 ecode2 = SWIG_AsVal_int(obj1, &val2);
5452 if (!SWIG_IsOK(ecode2)) {
5453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5454 }
5455 arg2 = static_cast< int >(val2);
5456 }
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5464 return resultobj;
5465 fail:
5466 return NULL;
5467 }
5468
5469
5470 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5471 PyObject *obj;
5472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5473 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5474 return SWIG_Py_Void();
5475 }
5476
5477 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5478 return SWIG_Python_InitShadowInstance(args);
5479 }
5480
5481 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483 wxGridCellBoolEditor *result = 0 ;
5484
5485 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5500 PyObject *resultobj = 0;
5501 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5502 wxString result;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 PyObject *swig_obj[1] ;
5506
5507 if (!args) SWIG_fail;
5508 swig_obj[0] = args;
5509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5510 if (!SWIG_IsOK(res1)) {
5511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5512 }
5513 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5514 {
5515 PyThreadState* __tstate = wxPyBeginAllowThreads();
5516 result = (arg1)->GetValue();
5517 wxPyEndAllowThreads(__tstate);
5518 if (PyErr_Occurred()) SWIG_fail;
5519 }
5520 {
5521 #if wxUSE_UNICODE
5522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5523 #else
5524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5525 #endif
5526 }
5527 return resultobj;
5528 fail:
5529 return NULL;
5530 }
5531
5532
5533 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 PyObject *obj;
5535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5536 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5537 return SWIG_Py_Void();
5538 }
5539
5540 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5541 return SWIG_Python_InitShadowInstance(args);
5542 }
5543
5544 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5545 PyObject *resultobj = 0;
5546 int arg1 = (int) 0 ;
5547 wxString *arg2 = (wxString *) NULL ;
5548 bool arg3 = (bool) false ;
5549 wxGridCellChoiceEditor *result = 0 ;
5550 bool val3 ;
5551 int ecode3 = 0 ;
5552 PyObject * obj0 = 0 ;
5553 PyObject * obj1 = 0 ;
5554 char * kwnames[] = {
5555 (char *) "choices",(char *) "allowOthers", NULL
5556 };
5557
5558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5559 if (obj0) {
5560 {
5561 arg1 = PyList_Size(obj0);
5562 arg2 = wxString_LIST_helper(obj0);
5563 if (arg2 == NULL) SWIG_fail;
5564 }
5565 }
5566 if (obj1) {
5567 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5568 if (!SWIG_IsOK(ecode3)) {
5569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5570 }
5571 arg3 = static_cast< bool >(val3);
5572 }
5573 {
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5580 {
5581 if (arg2) delete [] arg2;
5582 }
5583 return resultobj;
5584 fail:
5585 {
5586 if (arg2) delete [] arg2;
5587 }
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5595 wxString result;
5596 void *argp1 = 0 ;
5597 int res1 = 0 ;
5598 PyObject *swig_obj[1] ;
5599
5600 if (!args) SWIG_fail;
5601 swig_obj[0] = args;
5602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5605 }
5606 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 result = (arg1)->GetValue();
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 {
5614 #if wxUSE_UNICODE
5615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5616 #else
5617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5618 #endif
5619 }
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5627 PyObject *obj;
5628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5629 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5630 return SWIG_Py_Void();
5631 }
5632
5633 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 return SWIG_Python_InitShadowInstance(args);
5635 }
5636
5637 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj = 0;
5639 wxString const &arg1_defvalue = wxPyEmptyString ;
5640 wxString *arg1 = (wxString *) &arg1_defvalue ;
5641 wxGridCellEnumEditor *result = 0 ;
5642 bool temp1 = false ;
5643 PyObject * obj0 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "choices", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5649 if (obj0) {
5650 {
5651 arg1 = wxString_in_helper(obj0);
5652 if (arg1 == NULL) SWIG_fail;
5653 temp1 = true;
5654 }
5655 }
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5663 {
5664 if (temp1)
5665 delete arg1;
5666 }
5667 return resultobj;
5668 fail:
5669 {
5670 if (temp1)
5671 delete arg1;
5672 }
5673 return NULL;
5674 }
5675
5676
5677 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5678 PyObject *obj;
5679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5680 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5681 return SWIG_Py_Void();
5682 }
5683
5684 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 return SWIG_Python_InitShadowInstance(args);
5686 }
5687
5688 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *resultobj = 0;
5690 wxGridCellAutoWrapStringEditor *result = 0 ;
5691
5692 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5696 wxPyEndAllowThreads(__tstate);
5697 if (PyErr_Occurred()) SWIG_fail;
5698 }
5699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5707 PyObject *obj;
5708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5709 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5710 return SWIG_Py_Void();
5711 }
5712
5713 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5714 return SWIG_Python_InitShadowInstance(args);
5715 }
5716
5717 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5718 PyObject *resultobj = 0;
5719 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5720 PyObject *arg2 = (PyObject *) 0 ;
5721 void *argp1 = 0 ;
5722 int res1 = 0 ;
5723 PyObject * obj0 = 0 ;
5724 PyObject * obj1 = 0 ;
5725 char * kwnames[] = {
5726 (char *) "self",(char *) "_self", NULL
5727 };
5728
5729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5733 }
5734 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5735 arg2 = obj1;
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 wxGridCellAttr__setOORInfo(arg1,arg2);
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 resultobj = SWIG_Py_Void();
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj = 0;
5751 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5752 wxGridCellAttr *result = 0 ;
5753 void *argp1 = 0 ;
5754 int res1 = 0 ;
5755 PyObject * obj0 = 0 ;
5756 char * kwnames[] = {
5757 (char *) "attrDefault", NULL
5758 };
5759
5760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5761 if (obj0) {
5762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5765 }
5766 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5767 }
5768 {
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 {
5775 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5776 }
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5784 PyObject *resultobj = 0;
5785 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject *swig_obj[1] ;
5789
5790 if (!args) SWIG_fail;
5791 swig_obj[0] = args;
5792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5793 if (!SWIG_IsOK(res1)) {
5794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5795 }
5796 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5797 {
5798 PyThreadState* __tstate = wxPyBeginAllowThreads();
5799 delete_wxGridCellAttr(arg1);
5800
5801 wxPyEndAllowThreads(__tstate);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 resultobj = SWIG_Py_Void();
5805 return resultobj;
5806 fail:
5807 return NULL;
5808 }
5809
5810
5811 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5812 PyObject *resultobj = 0;
5813 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5814 wxGridCellAttr *result = 0 ;
5815 void *argp1 = 0 ;
5816 int res1 = 0 ;
5817 PyObject *swig_obj[1] ;
5818
5819 if (!args) SWIG_fail;
5820 swig_obj[0] = args;
5821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5822 if (!SWIG_IsOK(res1)) {
5823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5824 }
5825 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5826 {
5827 PyThreadState* __tstate = wxPyBeginAllowThreads();
5828 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5829 wxPyEndAllowThreads(__tstate);
5830 if (PyErr_Occurred()) SWIG_fail;
5831 }
5832 {
5833 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5834 }
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj = 0;
5843 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5844 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5845 void *argp1 = 0 ;
5846 int res1 = 0 ;
5847 void *argp2 = 0 ;
5848 int res2 = 0 ;
5849 PyObject * obj0 = 0 ;
5850 PyObject * obj1 = 0 ;
5851 char * kwnames[] = {
5852 (char *) "self",(char *) "mergefrom", NULL
5853 };
5854
5855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5857 if (!SWIG_IsOK(res1)) {
5858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5859 }
5860 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5862 if (!SWIG_IsOK(res2)) {
5863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5864 }
5865 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 (arg1)->MergeWith(arg2);
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 resultobj = SWIG_Py_Void();
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880 PyObject *resultobj = 0;
5881 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5882 void *argp1 = 0 ;
5883 int res1 = 0 ;
5884 PyObject *swig_obj[1] ;
5885
5886 if (!args) SWIG_fail;
5887 swig_obj[0] = args;
5888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5889 if (!SWIG_IsOK(res1)) {
5890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5891 }
5892 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 (arg1)->IncRef();
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 resultobj = SWIG_Py_Void();
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5907 PyObject *resultobj = 0;
5908 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5909 void *argp1 = 0 ;
5910 int res1 = 0 ;
5911 PyObject *swig_obj[1] ;
5912
5913 if (!args) SWIG_fail;
5914 swig_obj[0] = args;
5915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5916 if (!SWIG_IsOK(res1)) {
5917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5918 }
5919 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5920 {
5921 PyThreadState* __tstate = wxPyBeginAllowThreads();
5922 (arg1)->DecRef();
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 resultobj = SWIG_Py_Void();
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5934 PyObject *resultobj = 0;
5935 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5936 wxColour *arg2 = 0 ;
5937 void *argp1 = 0 ;
5938 int res1 = 0 ;
5939 wxColour temp2 ;
5940 PyObject * obj0 = 0 ;
5941 PyObject * obj1 = 0 ;
5942 char * kwnames[] = {
5943 (char *) "self",(char *) "colText", NULL
5944 };
5945
5946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5948 if (!SWIG_IsOK(res1)) {
5949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5950 }
5951 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5952 {
5953 arg2 = &temp2;
5954 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5955 }
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 (arg1)->SetTextColour((wxColour const &)*arg2);
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 resultobj = SWIG_Py_Void();
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj = 0;
5971 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5972 wxColour *arg2 = 0 ;
5973 void *argp1 = 0 ;
5974 int res1 = 0 ;
5975 wxColour temp2 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 char * kwnames[] = {
5979 (char *) "self",(char *) "colBack", NULL
5980 };
5981
5982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5984 if (!SWIG_IsOK(res1)) {
5985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5986 }
5987 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5988 {
5989 arg2 = &temp2;
5990 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5991 }
5992 {
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = SWIG_Py_Void();
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj = 0;
6007 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6008 wxFont *arg2 = 0 ;
6009 void *argp1 = 0 ;
6010 int res1 = 0 ;
6011 void *argp2 = 0 ;
6012 int res2 = 0 ;
6013 PyObject * obj0 = 0 ;
6014 PyObject * obj1 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "font", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6023 }
6024 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6026 if (!SWIG_IsOK(res2)) {
6027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6028 }
6029 if (!argp2) {
6030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6031 }
6032 arg2 = reinterpret_cast< wxFont * >(argp2);
6033 {
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 (arg1)->SetFont((wxFont const &)*arg2);
6036 wxPyEndAllowThreads(__tstate);
6037 if (PyErr_Occurred()) SWIG_fail;
6038 }
6039 resultobj = SWIG_Py_Void();
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj = 0;
6048 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6049 int arg2 ;
6050 int arg3 ;
6051 void *argp1 = 0 ;
6052 int res1 = 0 ;
6053 int val2 ;
6054 int ecode2 = 0 ;
6055 int val3 ;
6056 int ecode3 = 0 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 PyObject * obj2 = 0 ;
6060 char * kwnames[] = {
6061 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6062 };
6063
6064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6066 if (!SWIG_IsOK(res1)) {
6067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6068 }
6069 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6070 ecode2 = SWIG_AsVal_int(obj1, &val2);
6071 if (!SWIG_IsOK(ecode2)) {
6072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6073 }
6074 arg2 = static_cast< int >(val2);
6075 ecode3 = SWIG_AsVal_int(obj2, &val3);
6076 if (!SWIG_IsOK(ecode3)) {
6077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6078 }
6079 arg3 = static_cast< int >(val3);
6080 {
6081 PyThreadState* __tstate = wxPyBeginAllowThreads();
6082 (arg1)->SetAlignment(arg2,arg3);
6083 wxPyEndAllowThreads(__tstate);
6084 if (PyErr_Occurred()) SWIG_fail;
6085 }
6086 resultobj = SWIG_Py_Void();
6087 return resultobj;
6088 fail:
6089 return NULL;
6090 }
6091
6092
6093 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj = 0;
6095 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6096 int arg2 ;
6097 int arg3 ;
6098 void *argp1 = 0 ;
6099 int res1 = 0 ;
6100 int val2 ;
6101 int ecode2 = 0 ;
6102 int val3 ;
6103 int ecode3 = 0 ;
6104 PyObject * obj0 = 0 ;
6105 PyObject * obj1 = 0 ;
6106 PyObject * obj2 = 0 ;
6107 char * kwnames[] = {
6108 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6109 };
6110
6111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6113 if (!SWIG_IsOK(res1)) {
6114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6115 }
6116 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6117 ecode2 = SWIG_AsVal_int(obj1, &val2);
6118 if (!SWIG_IsOK(ecode2)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6120 }
6121 arg2 = static_cast< int >(val2);
6122 ecode3 = SWIG_AsVal_int(obj2, &val3);
6123 if (!SWIG_IsOK(ecode3)) {
6124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6125 }
6126 arg3 = static_cast< int >(val3);
6127 {
6128 PyThreadState* __tstate = wxPyBeginAllowThreads();
6129 (arg1)->SetSize(arg2,arg3);
6130 wxPyEndAllowThreads(__tstate);
6131 if (PyErr_Occurred()) SWIG_fail;
6132 }
6133 resultobj = SWIG_Py_Void();
6134 return resultobj;
6135 fail:
6136 return NULL;
6137 }
6138
6139
6140 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj = 0;
6142 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6143 bool arg2 = (bool) true ;
6144 void *argp1 = 0 ;
6145 int res1 = 0 ;
6146 bool val2 ;
6147 int ecode2 = 0 ;
6148 PyObject * obj0 = 0 ;
6149 PyObject * obj1 = 0 ;
6150 char * kwnames[] = {
6151 (char *) "self",(char *) "allow", NULL
6152 };
6153
6154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6156 if (!SWIG_IsOK(res1)) {
6157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6158 }
6159 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6160 if (obj1) {
6161 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6162 if (!SWIG_IsOK(ecode2)) {
6163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6164 }
6165 arg2 = static_cast< bool >(val2);
6166 }
6167 {
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 (arg1)->SetOverflow(arg2);
6170 wxPyEndAllowThreads(__tstate);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 resultobj = SWIG_Py_Void();
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6183 bool arg2 = (bool) true ;
6184 void *argp1 = 0 ;
6185 int res1 = 0 ;
6186 bool val2 ;
6187 int ecode2 = 0 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 char * kwnames[] = {
6191 (char *) "self",(char *) "isReadOnly", NULL
6192 };
6193
6194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6196 if (!SWIG_IsOK(res1)) {
6197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6198 }
6199 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6200 if (obj1) {
6201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6202 if (!SWIG_IsOK(ecode2)) {
6203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6204 }
6205 arg2 = static_cast< bool >(val2);
6206 }
6207 {
6208 PyThreadState* __tstate = wxPyBeginAllowThreads();
6209 (arg1)->SetReadOnly(arg2);
6210 wxPyEndAllowThreads(__tstate);
6211 if (PyErr_Occurred()) SWIG_fail;
6212 }
6213 resultobj = SWIG_Py_Void();
6214 return resultobj;
6215 fail:
6216 return NULL;
6217 }
6218
6219
6220 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6221 PyObject *resultobj = 0;
6222 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6223 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6224 void *argp1 = 0 ;
6225 int res1 = 0 ;
6226 void *argp2 = 0 ;
6227 int res2 = 0 ;
6228 PyObject * obj0 = 0 ;
6229 PyObject * obj1 = 0 ;
6230 char * kwnames[] = {
6231 (char *) "self",(char *) "renderer", NULL
6232 };
6233
6234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6236 if (!SWIG_IsOK(res1)) {
6237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6238 }
6239 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6240 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6241 if (!SWIG_IsOK(res2)) {
6242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6243 }
6244 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 (arg1)->SetRenderer(arg2);
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_Py_Void();
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6259 PyObject *resultobj = 0;
6260 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6261 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6262 void *argp1 = 0 ;
6263 int res1 = 0 ;
6264 void *argp2 = 0 ;
6265 int res2 = 0 ;
6266 PyObject * obj0 = 0 ;
6267 PyObject * obj1 = 0 ;
6268 char * kwnames[] = {
6269 (char *) "self",(char *) "editor", NULL
6270 };
6271
6272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6274 if (!SWIG_IsOK(res1)) {
6275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6276 }
6277 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6279 if (!SWIG_IsOK(res2)) {
6280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6281 }
6282 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6283 {
6284 PyThreadState* __tstate = wxPyBeginAllowThreads();
6285 (arg1)->SetEditor(arg2);
6286 wxPyEndAllowThreads(__tstate);
6287 if (PyErr_Occurred()) SWIG_fail;
6288 }
6289 resultobj = SWIG_Py_Void();
6290 return resultobj;
6291 fail:
6292 return NULL;
6293 }
6294
6295
6296 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6297 PyObject *resultobj = 0;
6298 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6299 wxGridCellAttr::wxAttrKind arg2 ;
6300 void *argp1 = 0 ;
6301 int res1 = 0 ;
6302 int val2 ;
6303 int ecode2 = 0 ;
6304 PyObject * obj0 = 0 ;
6305 PyObject * obj1 = 0 ;
6306 char * kwnames[] = {
6307 (char *) "self",(char *) "kind", NULL
6308 };
6309
6310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6312 if (!SWIG_IsOK(res1)) {
6313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6314 }
6315 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6316 ecode2 = SWIG_AsVal_int(obj1, &val2);
6317 if (!SWIG_IsOK(ecode2)) {
6318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6319 }
6320 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 (arg1)->SetKind(arg2);
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 resultobj = SWIG_Py_Void();
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6335 PyObject *resultobj = 0;
6336 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6337 bool result;
6338 void *argp1 = 0 ;
6339 int res1 = 0 ;
6340 PyObject *swig_obj[1] ;
6341
6342 if (!args) SWIG_fail;
6343 swig_obj[0] = args;
6344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6345 if (!SWIG_IsOK(res1)) {
6346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6347 }
6348 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6357 }
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6365 PyObject *resultobj = 0;
6366 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6367 bool result;
6368 void *argp1 = 0 ;
6369 int res1 = 0 ;
6370 PyObject *swig_obj[1] ;
6371
6372 if (!args) SWIG_fail;
6373 swig_obj[0] = args;
6374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6375 if (!SWIG_IsOK(res1)) {
6376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6377 }
6378 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6379 {
6380 PyThreadState* __tstate = wxPyBeginAllowThreads();
6381 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 {
6386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6387 }
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6397 bool result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 {
6416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6417 }
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425 PyObject *resultobj = 0;
6426 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6427 bool result;
6428 void *argp1 = 0 ;
6429 int res1 = 0 ;
6430 PyObject *swig_obj[1] ;
6431
6432 if (!args) SWIG_fail;
6433 swig_obj[0] = args;
6434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6437 }
6438 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 {
6446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6447 }
6448 return resultobj;
6449 fail:
6450 return NULL;
6451 }
6452
6453
6454 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6455 PyObject *resultobj = 0;
6456 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6457 bool result;
6458 void *argp1 = 0 ;
6459 int res1 = 0 ;
6460 PyObject *swig_obj[1] ;
6461
6462 if (!args) SWIG_fail;
6463 swig_obj[0] = args;
6464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6465 if (!SWIG_IsOK(res1)) {
6466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6467 }
6468 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6472 wxPyEndAllowThreads(__tstate);
6473 if (PyErr_Occurred()) SWIG_fail;
6474 }
6475 {
6476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6477 }
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 PyObject *resultobj = 0;
6486 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6487 bool result;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 PyObject *swig_obj[1] ;
6491
6492 if (!args) SWIG_fail;
6493 swig_obj[0] = args;
6494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6495 if (!SWIG_IsOK(res1)) {
6496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6497 }
6498 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6499 {
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 {
6506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6515 PyObject *resultobj = 0;
6516 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6517 bool result;
6518 void *argp1 = 0 ;
6519 int res1 = 0 ;
6520 PyObject *swig_obj[1] ;
6521
6522 if (!args) SWIG_fail;
6523 swig_obj[0] = args;
6524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6525 if (!SWIG_IsOK(res1)) {
6526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6527 }
6528 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 {
6536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6537 }
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545 PyObject *resultobj = 0;
6546 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6547 bool result;
6548 void *argp1 = 0 ;
6549 int res1 = 0 ;
6550 PyObject *swig_obj[1] ;
6551
6552 if (!args) SWIG_fail;
6553 swig_obj[0] = args;
6554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6555 if (!SWIG_IsOK(res1)) {
6556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6557 }
6558 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 {
6566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6567 }
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6577 wxColour result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6603 PyObject *resultobj = 0;
6604 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6605 wxColour result;
6606 void *argp1 = 0 ;
6607 int res1 = 0 ;
6608 PyObject *swig_obj[1] ;
6609
6610 if (!args) SWIG_fail;
6611 swig_obj[0] = args;
6612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6615 }
6616 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6631 PyObject *resultobj = 0;
6632 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6633 wxFont result;
6634 void *argp1 = 0 ;
6635 int res1 = 0 ;
6636 PyObject *swig_obj[1] ;
6637
6638 if (!args) SWIG_fail;
6639 swig_obj[0] = args;
6640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6641 if (!SWIG_IsOK(res1)) {
6642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6643 }
6644 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6645 {
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 result = ((wxGridCellAttr const *)arg1)->GetFont();
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6659 PyObject *resultobj = 0;
6660 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6661 int *arg2 = (int *) 0 ;
6662 int *arg3 = (int *) 0 ;
6663 void *argp1 = 0 ;
6664 int res1 = 0 ;
6665 int temp2 ;
6666 int res2 = SWIG_TMPOBJ ;
6667 int temp3 ;
6668 int res3 = SWIG_TMPOBJ ;
6669 PyObject *swig_obj[1] ;
6670
6671 arg2 = &temp2;
6672 arg3 = &temp3;
6673 if (!args) SWIG_fail;
6674 swig_obj[0] = args;
6675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6678 }
6679 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 resultobj = SWIG_Py_Void();
6687 if (SWIG_IsTmpObj(res2)) {
6688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6689 } else {
6690 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6692 }
6693 if (SWIG_IsTmpObj(res3)) {
6694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6695 } else {
6696 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6706 PyObject *resultobj = 0;
6707 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6708 int *arg2 = (int *) 0 ;
6709 int *arg3 = (int *) 0 ;
6710 void *argp1 = 0 ;
6711 int res1 = 0 ;
6712 int temp2 ;
6713 int res2 = SWIG_TMPOBJ ;
6714 int temp3 ;
6715 int res3 = SWIG_TMPOBJ ;
6716 PyObject *swig_obj[1] ;
6717
6718 arg2 = &temp2;
6719 arg3 = &temp3;
6720 if (!args) SWIG_fail;
6721 swig_obj[0] = args;
6722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6723 if (!SWIG_IsOK(res1)) {
6724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6725 }
6726 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_Py_Void();
6734 if (SWIG_IsTmpObj(res2)) {
6735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6736 } else {
6737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6739 }
6740 if (SWIG_IsTmpObj(res3)) {
6741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6742 } else {
6743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6745 }
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6753 PyObject *resultobj = 0;
6754 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6755 bool result;
6756 void *argp1 = 0 ;
6757 int res1 = 0 ;
6758 PyObject *swig_obj[1] ;
6759
6760 if (!args) SWIG_fail;
6761 swig_obj[0] = args;
6762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6763 if (!SWIG_IsOK(res1)) {
6764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6765 }
6766 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6767 {
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 {
6774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6775 }
6776 return resultobj;
6777 fail:
6778 return NULL;
6779 }
6780
6781
6782 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6783 PyObject *resultobj = 0;
6784 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6785 wxGrid *arg2 = (wxGrid *) 0 ;
6786 int arg3 ;
6787 int arg4 ;
6788 wxGridCellRenderer *result = 0 ;
6789 void *argp1 = 0 ;
6790 int res1 = 0 ;
6791 void *argp2 = 0 ;
6792 int res2 = 0 ;
6793 int val3 ;
6794 int ecode3 = 0 ;
6795 int val4 ;
6796 int ecode4 = 0 ;
6797 PyObject * obj0 = 0 ;
6798 PyObject * obj1 = 0 ;
6799 PyObject * obj2 = 0 ;
6800 PyObject * obj3 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6809 }
6810 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6812 if (!SWIG_IsOK(res2)) {
6813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6814 }
6815 arg2 = reinterpret_cast< wxGrid * >(argp2);
6816 ecode3 = SWIG_AsVal_int(obj2, &val3);
6817 if (!SWIG_IsOK(ecode3)) {
6818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6819 }
6820 arg3 = static_cast< int >(val3);
6821 ecode4 = SWIG_AsVal_int(obj3, &val4);
6822 if (!SWIG_IsOK(ecode4)) {
6823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6824 }
6825 arg4 = static_cast< int >(val4);
6826 {
6827 PyThreadState* __tstate = wxPyBeginAllowThreads();
6828 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6829 wxPyEndAllowThreads(__tstate);
6830 if (PyErr_Occurred()) SWIG_fail;
6831 }
6832 {
6833 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6834 }
6835 return resultobj;
6836 fail:
6837 return NULL;
6838 }
6839
6840
6841 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6842 PyObject *resultobj = 0;
6843 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6844 wxGrid *arg2 = (wxGrid *) 0 ;
6845 int arg3 ;
6846 int arg4 ;
6847 wxGridCellEditor *result = 0 ;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 void *argp2 = 0 ;
6851 int res2 = 0 ;
6852 int val3 ;
6853 int ecode3 = 0 ;
6854 int val4 ;
6855 int ecode4 = 0 ;
6856 PyObject * obj0 = 0 ;
6857 PyObject * obj1 = 0 ;
6858 PyObject * obj2 = 0 ;
6859 PyObject * obj3 = 0 ;
6860 char * kwnames[] = {
6861 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6862 };
6863
6864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6866 if (!SWIG_IsOK(res1)) {
6867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6868 }
6869 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6871 if (!SWIG_IsOK(res2)) {
6872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6873 }
6874 arg2 = reinterpret_cast< wxGrid * >(argp2);
6875 ecode3 = SWIG_AsVal_int(obj2, &val3);
6876 if (!SWIG_IsOK(ecode3)) {
6877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6878 }
6879 arg3 = static_cast< int >(val3);
6880 ecode4 = SWIG_AsVal_int(obj3, &val4);
6881 if (!SWIG_IsOK(ecode4)) {
6882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6883 }
6884 arg4 = static_cast< int >(val4);
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6901 PyObject *resultobj = 0;
6902 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6903 bool result;
6904 void *argp1 = 0 ;
6905 int res1 = 0 ;
6906 PyObject *swig_obj[1] ;
6907
6908 if (!args) SWIG_fail;
6909 swig_obj[0] = args;
6910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6911 if (!SWIG_IsOK(res1)) {
6912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6913 }
6914 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6915 {
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6931 PyObject *resultobj = 0;
6932 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6933 wxGridCellAttr::wxAttrKind result;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936 PyObject *swig_obj[1] ;
6937
6938 if (!args) SWIG_fail;
6939 swig_obj[0] = args;
6940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6943 }
6944 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_From_int(static_cast< int >(result));
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6961 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 void *argp2 = 0 ;
6965 int res2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "defAttr", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6976 }
6977 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6979 if (!SWIG_IsOK(res2)) {
6980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6981 }
6982 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetDefAttr(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6997 PyObject *obj;
6998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6999 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7000 return SWIG_Py_Void();
7001 }
7002
7003 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7004 return SWIG_Python_InitShadowInstance(args);
7005 }
7006
7007 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7008 PyObject *resultobj = 0;
7009 wxGridCellAttrProvider *result = 0 ;
7010
7011 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 {
7019 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj = 0;
7029 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7030 PyObject *arg2 = (PyObject *) 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char * kwnames[] = {
7036 (char *) "self",(char *) "_self", NULL
7037 };
7038
7039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7043 }
7044 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7045 arg2 = obj1;
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 resultobj = SWIG_Py_Void();
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7060 PyObject *resultobj = 0;
7061 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7062 int arg2 ;
7063 int arg3 ;
7064 wxGridCellAttr::wxAttrKind arg4 ;
7065 wxGridCellAttr *result = 0 ;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 int val2 ;
7069 int ecode2 = 0 ;
7070 int val3 ;
7071 int ecode3 = 0 ;
7072 int val4 ;
7073 int ecode4 = 0 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 PyObject * obj2 = 0 ;
7077 PyObject * obj3 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7084 if (!SWIG_IsOK(res1)) {
7085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7086 }
7087 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7088 ecode2 = SWIG_AsVal_int(obj1, &val2);
7089 if (!SWIG_IsOK(ecode2)) {
7090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7091 }
7092 arg2 = static_cast< int >(val2);
7093 ecode3 = SWIG_AsVal_int(obj2, &val3);
7094 if (!SWIG_IsOK(ecode3)) {
7095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7096 }
7097 arg3 = static_cast< int >(val3);
7098 ecode4 = SWIG_AsVal_int(obj3, &val4);
7099 if (!SWIG_IsOK(ecode4)) {
7100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7101 }
7102 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7103 {
7104 PyThreadState* __tstate = wxPyBeginAllowThreads();
7105 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj = 0;
7120 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7121 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7122 int arg3 ;
7123 int arg4 ;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 void *argp2 = 0 ;
7127 int res2 = 0 ;
7128 int val3 ;
7129 int ecode3 = 0 ;
7130 int val4 ;
7131 int ecode4 = 0 ;
7132 PyObject * obj0 = 0 ;
7133 PyObject * obj1 = 0 ;
7134 PyObject * obj2 = 0 ;
7135 PyObject * obj3 = 0 ;
7136 char * kwnames[] = {
7137 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7138 };
7139
7140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7144 }
7145 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7147 if (!SWIG_IsOK(res2)) {
7148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7149 }
7150 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7151 ecode3 = SWIG_AsVal_int(obj2, &val3);
7152 if (!SWIG_IsOK(ecode3)) {
7153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7154 }
7155 arg3 = static_cast< int >(val3);
7156 ecode4 = SWIG_AsVal_int(obj3, &val4);
7157 if (!SWIG_IsOK(ecode4)) {
7158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7159 }
7160 arg4 = static_cast< int >(val4);
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 (arg1)->SetAttr(arg2,arg3,arg4);
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 resultobj = SWIG_Py_Void();
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7177 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7178 int arg3 ;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 void *argp2 = 0 ;
7182 int res2 = 0 ;
7183 int val3 ;
7184 int ecode3 = 0 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 PyObject * obj2 = 0 ;
7188 char * kwnames[] = {
7189 (char *) "self",(char *) "attr",(char *) "row", NULL
7190 };
7191
7192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7196 }
7197 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7199 if (!SWIG_IsOK(res2)) {
7200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7201 }
7202 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7203 ecode3 = SWIG_AsVal_int(obj2, &val3);
7204 if (!SWIG_IsOK(ecode3)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7206 }
7207 arg3 = static_cast< int >(val3);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 (arg1)->SetRowAttr(arg2,arg3);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_Py_Void();
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7224 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7225 int arg3 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 void *argp2 = 0 ;
7229 int res2 = 0 ;
7230 int val3 ;
7231 int ecode3 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 PyObject * obj2 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "attr",(char *) "col", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7243 }
7244 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7246 if (!SWIG_IsOK(res2)) {
7247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7248 }
7249 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7250 ecode3 = SWIG_AsVal_int(obj2, &val3);
7251 if (!SWIG_IsOK(ecode3)) {
7252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7253 }
7254 arg3 = static_cast< int >(val3);
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 (arg1)->SetColAttr(arg2,arg3);
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_Py_Void();
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7271 size_t arg2 ;
7272 int arg3 ;
7273 void *argp1 = 0 ;
7274 int res1 = 0 ;
7275 size_t val2 ;
7276 int ecode2 = 0 ;
7277 int val3 ;
7278 int ecode3 = 0 ;
7279 PyObject * obj0 = 0 ;
7280 PyObject * obj1 = 0 ;
7281 PyObject * obj2 = 0 ;
7282 char * kwnames[] = {
7283 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7284 };
7285
7286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7288 if (!SWIG_IsOK(res1)) {
7289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7290 }
7291 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7292 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7293 if (!SWIG_IsOK(ecode2)) {
7294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7295 }
7296 arg2 = static_cast< size_t >(val2);
7297 ecode3 = SWIG_AsVal_int(obj2, &val3);
7298 if (!SWIG_IsOK(ecode3)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7300 }
7301 arg3 = static_cast< int >(val3);
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 (arg1)->UpdateAttrRows(arg2,arg3);
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_Py_Void();
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj = 0;
7317 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7318 size_t arg2 ;
7319 int arg3 ;
7320 void *argp1 = 0 ;
7321 int res1 = 0 ;
7322 size_t val2 ;
7323 int ecode2 = 0 ;
7324 int val3 ;
7325 int ecode3 = 0 ;
7326 PyObject * obj0 = 0 ;
7327 PyObject * obj1 = 0 ;
7328 PyObject * obj2 = 0 ;
7329 char * kwnames[] = {
7330 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7331 };
7332
7333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7335 if (!SWIG_IsOK(res1)) {
7336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7337 }
7338 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7339 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7340 if (!SWIG_IsOK(ecode2)) {
7341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7342 }
7343 arg2 = static_cast< size_t >(val2);
7344 ecode3 = SWIG_AsVal_int(obj2, &val3);
7345 if (!SWIG_IsOK(ecode3)) {
7346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7347 }
7348 arg3 = static_cast< int >(val3);
7349 {
7350 PyThreadState* __tstate = wxPyBeginAllowThreads();
7351 (arg1)->UpdateAttrCols(arg2,arg3);
7352 wxPyEndAllowThreads(__tstate);
7353 if (PyErr_Occurred()) SWIG_fail;
7354 }
7355 resultobj = SWIG_Py_Void();
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7363 PyObject *obj;
7364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7366 return SWIG_Py_Void();
7367 }
7368
7369 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7370 return SWIG_Python_InitShadowInstance(args);
7371 }
7372
7373 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7374 PyObject *resultobj = 0;
7375 wxPyGridCellAttrProvider *result = 0 ;
7376
7377 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7378 {
7379 PyThreadState* __tstate = wxPyBeginAllowThreads();
7380 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7381 wxPyEndAllowThreads(__tstate);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj = 0;
7393 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7394 PyObject *arg2 = (PyObject *) 0 ;
7395 PyObject *arg3 = (PyObject *) 0 ;
7396 void *argp1 = 0 ;
7397 int res1 = 0 ;
7398 PyObject * obj0 = 0 ;
7399 PyObject * obj1 = 0 ;
7400 PyObject * obj2 = 0 ;
7401 char * kwnames[] = {
7402 (char *) "self",(char *) "self",(char *) "_class", NULL
7403 };
7404
7405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7407 if (!SWIG_IsOK(res1)) {
7408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7409 }
7410 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7411 arg2 = obj1;
7412 arg3 = obj2;
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 (arg1)->_setCallbackInfo(arg2,arg3);
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_Py_Void();
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7429 int arg2 ;
7430 int arg3 ;
7431 wxGridCellAttr::wxAttrKind arg4 ;
7432 wxGridCellAttr *result = 0 ;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 int val2 ;
7436 int ecode2 = 0 ;
7437 int val3 ;
7438 int ecode3 = 0 ;
7439 int val4 ;
7440 int ecode4 = 0 ;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 PyObject * obj2 = 0 ;
7444 PyObject * obj3 = 0 ;
7445 char * kwnames[] = {
7446 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7447 };
7448
7449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7451 if (!SWIG_IsOK(res1)) {
7452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7453 }
7454 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7455 ecode2 = SWIG_AsVal_int(obj1, &val2);
7456 if (!SWIG_IsOK(ecode2)) {
7457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7458 }
7459 arg2 = static_cast< int >(val2);
7460 ecode3 = SWIG_AsVal_int(obj2, &val3);
7461 if (!SWIG_IsOK(ecode3)) {
7462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7463 }
7464 arg3 = static_cast< int >(val3);
7465 ecode4 = SWIG_AsVal_int(obj3, &val4);
7466 if (!SWIG_IsOK(ecode4)) {
7467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7468 }
7469 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7470 {
7471 PyThreadState* __tstate = wxPyBeginAllowThreads();
7472 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 {
7477 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7478 }
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7488 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7489 int arg3 ;
7490 int arg4 ;
7491 void *argp1 = 0 ;
7492 int res1 = 0 ;
7493 void *argp2 = 0 ;
7494 int res2 = 0 ;
7495 int val3 ;
7496 int ecode3 = 0 ;
7497 int val4 ;
7498 int ecode4 = 0 ;
7499 PyObject * obj0 = 0 ;
7500 PyObject * obj1 = 0 ;
7501 PyObject * obj2 = 0 ;
7502 PyObject * obj3 = 0 ;
7503 char * kwnames[] = {
7504 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7505 };
7506
7507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7509 if (!SWIG_IsOK(res1)) {
7510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7511 }
7512 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7514 if (!SWIG_IsOK(res2)) {
7515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7516 }
7517 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7518 ecode3 = SWIG_AsVal_int(obj2, &val3);
7519 if (!SWIG_IsOK(ecode3)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7521 }
7522 arg3 = static_cast< int >(val3);
7523 ecode4 = SWIG_AsVal_int(obj3, &val4);
7524 if (!SWIG_IsOK(ecode4)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7526 }
7527 arg4 = static_cast< int >(val4);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 (arg1)->SetAttr(arg2,arg3,arg4);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj = 0;
7543 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7544 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7545 int arg3 ;
7546 void *argp1 = 0 ;
7547 int res1 = 0 ;
7548 void *argp2 = 0 ;
7549 int res2 = 0 ;
7550 int val3 ;
7551 int ecode3 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 PyObject * obj2 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "attr",(char *) "row", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7563 }
7564 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7565 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7566 if (!SWIG_IsOK(res2)) {
7567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7568 }
7569 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7570 ecode3 = SWIG_AsVal_int(obj2, &val3);
7571 if (!SWIG_IsOK(ecode3)) {
7572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7573 }
7574 arg3 = static_cast< int >(val3);
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 (arg1)->SetRowAttr(arg2,arg3);
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 resultobj = SWIG_Py_Void();
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj = 0;
7590 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7591 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7592 int arg3 ;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 void *argp2 = 0 ;
7596 int res2 = 0 ;
7597 int val3 ;
7598 int ecode3 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 PyObject * obj2 = 0 ;
7602 char * kwnames[] = {
7603 (char *) "self",(char *) "attr",(char *) "col", NULL
7604 };
7605
7606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7608 if (!SWIG_IsOK(res1)) {
7609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7610 }
7611 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7613 if (!SWIG_IsOK(res2)) {
7614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7615 }
7616 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7617 ecode3 = SWIG_AsVal_int(obj2, &val3);
7618 if (!SWIG_IsOK(ecode3)) {
7619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7620 }
7621 arg3 = static_cast< int >(val3);
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 (arg1)->SetColAttr(arg2,arg3);
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 resultobj = SWIG_Py_Void();
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7636 PyObject *obj;
7637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7638 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7639 return SWIG_Py_Void();
7640 }
7641
7642 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 return SWIG_Python_InitShadowInstance(args);
7644 }
7645
7646 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 PyObject *resultobj = 0;
7648 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7649 void *argp1 = 0 ;
7650 int res1 = 0 ;
7651 PyObject *swig_obj[1] ;
7652
7653 if (!args) SWIG_fail;
7654 swig_obj[0] = args;
7655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7656 if (!SWIG_IsOK(res1)) {
7657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7658 }
7659 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 delete arg1;
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 resultobj = SWIG_Py_Void();
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = 0;
7676 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7677 PyObject *arg2 = (PyObject *) 0 ;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 PyObject * obj0 = 0 ;
7681 PyObject * obj1 = 0 ;
7682 char * kwnames[] = {
7683 (char *) "self",(char *) "_self", NULL
7684 };
7685
7686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7688 if (!SWIG_IsOK(res1)) {
7689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7690 }
7691 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7692 arg2 = obj1;
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 wxGridTableBase__setOORInfo(arg1,arg2);
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 resultobj = SWIG_Py_Void();
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7709 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 void *argp2 = 0 ;
7713 int res2 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "attrProvider", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7724 }
7725 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7727 if (!SWIG_IsOK(res2)) {
7728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7729 }
7730 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 (arg1)->SetAttrProvider(arg2);
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 resultobj = SWIG_Py_Void();
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7745 PyObject *resultobj = 0;
7746 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7747 wxGridCellAttrProvider *result = 0 ;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 PyObject *swig_obj[1] ;
7751
7752 if (!args) SWIG_fail;
7753 swig_obj[0] = args;
7754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7755 if (!SWIG_IsOK(res1)) {
7756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7757 }
7758 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7762 wxPyEndAllowThreads(__tstate);
7763 if (PyErr_Occurred()) SWIG_fail;
7764 }
7765 {
7766 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7767 }
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj = 0;
7776 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7777 wxGrid *arg2 = (wxGrid *) 0 ;
7778 void *argp1 = 0 ;
7779 int res1 = 0 ;
7780 void *argp2 = 0 ;
7781 int res2 = 0 ;
7782 PyObject * obj0 = 0 ;
7783 PyObject * obj1 = 0 ;
7784 char * kwnames[] = {
7785 (char *) "self",(char *) "grid", NULL
7786 };
7787
7788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7790 if (!SWIG_IsOK(res1)) {
7791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7792 }
7793 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7795 if (!SWIG_IsOK(res2)) {
7796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7797 }
7798 arg2 = reinterpret_cast< wxGrid * >(argp2);
7799 {
7800 PyThreadState* __tstate = wxPyBeginAllowThreads();
7801 (arg1)->SetView(arg2);
7802 wxPyEndAllowThreads(__tstate);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 resultobj = SWIG_Py_Void();
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7813 PyObject *resultobj = 0;
7814 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7815 wxGrid *result = 0 ;
7816 void *argp1 = 0 ;
7817 int res1 = 0 ;
7818 PyObject *swig_obj[1] ;
7819
7820 if (!args) SWIG_fail;
7821 swig_obj[0] = args;
7822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7825 }
7826 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7827 {
7828 PyThreadState* __tstate = wxPyBeginAllowThreads();
7829 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7830 wxPyEndAllowThreads(__tstate);
7831 if (PyErr_Occurred()) SWIG_fail;
7832 }
7833 {
7834 resultobj = wxPyMake_wxObject(result, (bool)0);
7835 }
7836 return resultobj;
7837 fail:
7838 return NULL;
7839 }
7840
7841
7842 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843 PyObject *resultobj = 0;
7844 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7845 int result;
7846 void *argp1 = 0 ;
7847 int res1 = 0 ;
7848 PyObject *swig_obj[1] ;
7849
7850 if (!args) SWIG_fail;
7851 swig_obj[0] = args;
7852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7853 if (!SWIG_IsOK(res1)) {
7854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7855 }
7856 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (int)(arg1)->GetNumberRows();
7860 wxPyEndAllowThreads(__tstate);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 resultobj = SWIG_From_int(static_cast< int >(result));
7864 return resultobj;
7865 fail:
7866 return NULL;
7867 }
7868
7869
7870 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7871 PyObject *resultobj = 0;
7872 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7873 int result;
7874 void *argp1 = 0 ;
7875 int res1 = 0 ;
7876 PyObject *swig_obj[1] ;
7877
7878 if (!args) SWIG_fail;
7879 swig_obj[0] = args;
7880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7881 if (!SWIG_IsOK(res1)) {
7882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7883 }
7884 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 result = (int)(arg1)->GetNumberCols();
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_From_int(static_cast< int >(result));
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7901 int arg2 ;
7902 int arg3 ;
7903 bool result;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 int val2 ;
7907 int ecode2 = 0 ;
7908 int val3 ;
7909 int ecode3 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 PyObject * obj2 = 0 ;
7913 char * kwnames[] = {
7914 (char *) "self",(char *) "row",(char *) "col", NULL
7915 };
7916
7917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7919 if (!SWIG_IsOK(res1)) {
7920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7921 }
7922 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7923 ecode2 = SWIG_AsVal_int(obj1, &val2);
7924 if (!SWIG_IsOK(ecode2)) {
7925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7926 }
7927 arg2 = static_cast< int >(val2);
7928 ecode3 = SWIG_AsVal_int(obj2, &val3);
7929 if (!SWIG_IsOK(ecode3)) {
7930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7931 }
7932 arg3 = static_cast< int >(val3);
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 {
7940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7941 }
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7951 int arg2 ;
7952 int arg3 ;
7953 wxString result;
7954 void *argp1 = 0 ;
7955 int res1 = 0 ;
7956 int val2 ;
7957 int ecode2 = 0 ;
7958 int val3 ;
7959 int ecode3 = 0 ;
7960 PyObject * obj0 = 0 ;
7961 PyObject * obj1 = 0 ;
7962 PyObject * obj2 = 0 ;
7963 char * kwnames[] = {
7964 (char *) "self",(char *) "row",(char *) "col", NULL
7965 };
7966
7967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7969 if (!SWIG_IsOK(res1)) {
7970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7971 }
7972 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7973 ecode2 = SWIG_AsVal_int(obj1, &val2);
7974 if (!SWIG_IsOK(ecode2)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7976 }
7977 arg2 = static_cast< int >(val2);
7978 ecode3 = SWIG_AsVal_int(obj2, &val3);
7979 if (!SWIG_IsOK(ecode3)) {
7980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7981 }
7982 arg3 = static_cast< int >(val3);
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = (arg1)->GetValue(arg2,arg3);
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 {
7990 #if wxUSE_UNICODE
7991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7992 #else
7993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7994 #endif
7995 }
7996 return resultobj;
7997 fail:
7998 return NULL;
7999 }
8000
8001
8002 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8003 PyObject *resultobj = 0;
8004 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8005 int arg2 ;
8006 int arg3 ;
8007 wxString *arg4 = 0 ;
8008 void *argp1 = 0 ;
8009 int res1 = 0 ;
8010 int val2 ;
8011 int ecode2 = 0 ;
8012 int val3 ;
8013 int ecode3 = 0 ;
8014 bool temp4 = false ;
8015 PyObject * obj0 = 0 ;
8016 PyObject * obj1 = 0 ;
8017 PyObject * obj2 = 0 ;
8018 PyObject * obj3 = 0 ;
8019 char * kwnames[] = {
8020 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8021 };
8022
8023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8027 }
8028 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8029 ecode2 = SWIG_AsVal_int(obj1, &val2);
8030 if (!SWIG_IsOK(ecode2)) {
8031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8032 }
8033 arg2 = static_cast< int >(val2);
8034 ecode3 = SWIG_AsVal_int(obj2, &val3);
8035 if (!SWIG_IsOK(ecode3)) {
8036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8037 }
8038 arg3 = static_cast< int >(val3);
8039 {
8040 arg4 = wxString_in_helper(obj3);
8041 if (arg4 == NULL) SWIG_fail;
8042 temp4 = true;
8043 }
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_Py_Void();
8051 {
8052 if (temp4)
8053 delete arg4;
8054 }
8055 return resultobj;
8056 fail:
8057 {
8058 if (temp4)
8059 delete arg4;
8060 }
8061 return NULL;
8062 }
8063
8064
8065 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj = 0;
8067 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8068 int arg2 ;
8069 int arg3 ;
8070 wxString result;
8071 void *argp1 = 0 ;
8072 int res1 = 0 ;
8073 int val2 ;
8074 int ecode2 = 0 ;
8075 int val3 ;
8076 int ecode3 = 0 ;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 PyObject * obj2 = 0 ;
8080 char * kwnames[] = {
8081 (char *) "self",(char *) "row",(char *) "col", NULL
8082 };
8083
8084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8086 if (!SWIG_IsOK(res1)) {
8087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8088 }
8089 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8090 ecode2 = SWIG_AsVal_int(obj1, &val2);
8091 if (!SWIG_IsOK(ecode2)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8093 }
8094 arg2 = static_cast< int >(val2);
8095 ecode3 = SWIG_AsVal_int(obj2, &val3);
8096 if (!SWIG_IsOK(ecode3)) {
8097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8098 }
8099 arg3 = static_cast< int >(val3);
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (arg1)->GetTypeName(arg2,arg3);
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 {
8107 #if wxUSE_UNICODE
8108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8109 #else
8110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8111 #endif
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj = 0;
8121 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8122 int arg2 ;
8123 int arg3 ;
8124 wxString *arg4 = 0 ;
8125 bool result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 int val2 ;
8129 int ecode2 = 0 ;
8130 int val3 ;
8131 int ecode3 = 0 ;
8132 bool temp4 = false ;
8133 PyObject * obj0 = 0 ;
8134 PyObject * obj1 = 0 ;
8135 PyObject * obj2 = 0 ;
8136 PyObject * obj3 = 0 ;
8137 char * kwnames[] = {
8138 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8139 };
8140
8141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8143 if (!SWIG_IsOK(res1)) {
8144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8145 }
8146 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8147 ecode2 = SWIG_AsVal_int(obj1, &val2);
8148 if (!SWIG_IsOK(ecode2)) {
8149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8150 }
8151 arg2 = static_cast< int >(val2);
8152 ecode3 = SWIG_AsVal_int(obj2, &val3);
8153 if (!SWIG_IsOK(ecode3)) {
8154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8155 }
8156 arg3 = static_cast< int >(val3);
8157 {
8158 arg4 = wxString_in_helper(obj3);
8159 if (arg4 == NULL) SWIG_fail;
8160 temp4 = true;
8161 }
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 {
8172 if (temp4)
8173 delete arg4;
8174 }
8175 return resultobj;
8176 fail:
8177 {
8178 if (temp4)
8179 delete arg4;
8180 }
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8188 int arg2 ;
8189 int arg3 ;
8190 wxString *arg4 = 0 ;
8191 bool result;
8192 void *argp1 = 0 ;
8193 int res1 = 0 ;
8194 int val2 ;
8195 int ecode2 = 0 ;
8196 int val3 ;
8197 int ecode3 = 0 ;
8198 bool temp4 = false ;
8199 PyObject * obj0 = 0 ;
8200 PyObject * obj1 = 0 ;
8201 PyObject * obj2 = 0 ;
8202 PyObject * obj3 = 0 ;
8203 char * kwnames[] = {
8204 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8205 };
8206
8207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8209 if (!SWIG_IsOK(res1)) {
8210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8211 }
8212 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8213 ecode2 = SWIG_AsVal_int(obj1, &val2);
8214 if (!SWIG_IsOK(ecode2)) {
8215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8216 }
8217 arg2 = static_cast< int >(val2);
8218 ecode3 = SWIG_AsVal_int(obj2, &val3);
8219 if (!SWIG_IsOK(ecode3)) {
8220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8221 }
8222 arg3 = static_cast< int >(val3);
8223 {
8224 arg4 = wxString_in_helper(obj3);
8225 if (arg4 == NULL) SWIG_fail;
8226 temp4 = true;
8227 }
8228 {
8229 PyThreadState* __tstate = wxPyBeginAllowThreads();
8230 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 {
8235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8236 }
8237 {
8238 if (temp4)
8239 delete arg4;
8240 }
8241 return resultobj;
8242 fail:
8243 {
8244 if (temp4)
8245 delete arg4;
8246 }
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj = 0;
8253 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8254 int arg2 ;
8255 int arg3 ;
8256 long result;
8257 void *argp1 = 0 ;
8258 int res1 = 0 ;
8259 int val2 ;
8260 int ecode2 = 0 ;
8261 int val3 ;
8262 int ecode3 = 0 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 PyObject * obj2 = 0 ;
8266 char * kwnames[] = {
8267 (char *) "self",(char *) "row",(char *) "col", NULL
8268 };
8269
8270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8272 if (!SWIG_IsOK(res1)) {
8273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8274 }
8275 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8276 ecode2 = SWIG_AsVal_int(obj1, &val2);
8277 if (!SWIG_IsOK(ecode2)) {
8278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8279 }
8280 arg2 = static_cast< int >(val2);
8281 ecode3 = SWIG_AsVal_int(obj2, &val3);
8282 if (!SWIG_IsOK(ecode3)) {
8283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8284 }
8285 arg3 = static_cast< int >(val3);
8286 {
8287 PyThreadState* __tstate = wxPyBeginAllowThreads();
8288 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8289 wxPyEndAllowThreads(__tstate);
8290 if (PyErr_Occurred()) SWIG_fail;
8291 }
8292 resultobj = SWIG_From_long(static_cast< long >(result));
8293 return resultobj;
8294 fail:
8295 return NULL;
8296 }
8297
8298
8299 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8300 PyObject *resultobj = 0;
8301 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8302 int arg2 ;
8303 int arg3 ;
8304 double result;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 int val2 ;
8308 int ecode2 = 0 ;
8309 int val3 ;
8310 int ecode3 = 0 ;
8311 PyObject * obj0 = 0 ;
8312 PyObject * obj1 = 0 ;
8313 PyObject * obj2 = 0 ;
8314 char * kwnames[] = {
8315 (char *) "self",(char *) "row",(char *) "col", NULL
8316 };
8317
8318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8320 if (!SWIG_IsOK(res1)) {
8321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8322 }
8323 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8324 ecode2 = SWIG_AsVal_int(obj1, &val2);
8325 if (!SWIG_IsOK(ecode2)) {
8326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8327 }
8328 arg2 = static_cast< int >(val2);
8329 ecode3 = SWIG_AsVal_int(obj2, &val3);
8330 if (!SWIG_IsOK(ecode3)) {
8331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8332 }
8333 arg3 = static_cast< int >(val3);
8334 {
8335 PyThreadState* __tstate = wxPyBeginAllowThreads();
8336 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 resultobj = SWIG_From_double(static_cast< double >(result));
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8348 PyObject *resultobj = 0;
8349 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8350 int arg2 ;
8351 int arg3 ;
8352 bool result;
8353 void *argp1 = 0 ;
8354 int res1 = 0 ;
8355 int val2 ;
8356 int ecode2 = 0 ;
8357 int val3 ;
8358 int ecode3 = 0 ;
8359 PyObject * obj0 = 0 ;
8360 PyObject * obj1 = 0 ;
8361 PyObject * obj2 = 0 ;
8362 char * kwnames[] = {
8363 (char *) "self",(char *) "row",(char *) "col", NULL
8364 };
8365
8366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8368 if (!SWIG_IsOK(res1)) {
8369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8370 }
8371 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8372 ecode2 = SWIG_AsVal_int(obj1, &val2);
8373 if (!SWIG_IsOK(ecode2)) {
8374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8375 }
8376 arg2 = static_cast< int >(val2);
8377 ecode3 = SWIG_AsVal_int(obj2, &val3);
8378 if (!SWIG_IsOK(ecode3)) {
8379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8380 }
8381 arg3 = static_cast< int >(val3);
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 {
8389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8390 }
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = 0;
8399 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8400 int arg2 ;
8401 int arg3 ;
8402 long arg4 ;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 int val2 ;
8406 int ecode2 = 0 ;
8407 int val3 ;
8408 int ecode3 = 0 ;
8409 long val4 ;
8410 int ecode4 = 0 ;
8411 PyObject * obj0 = 0 ;
8412 PyObject * obj1 = 0 ;
8413 PyObject * obj2 = 0 ;
8414 PyObject * obj3 = 0 ;
8415 char * kwnames[] = {
8416 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8417 };
8418
8419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8421 if (!SWIG_IsOK(res1)) {
8422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8423 }
8424 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8425 ecode2 = SWIG_AsVal_int(obj1, &val2);
8426 if (!SWIG_IsOK(ecode2)) {
8427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8428 }
8429 arg2 = static_cast< int >(val2);
8430 ecode3 = SWIG_AsVal_int(obj2, &val3);
8431 if (!SWIG_IsOK(ecode3)) {
8432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8433 }
8434 arg3 = static_cast< int >(val3);
8435 ecode4 = SWIG_AsVal_long(obj3, &val4);
8436 if (!SWIG_IsOK(ecode4)) {
8437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8438 }
8439 arg4 = static_cast< long >(val4);
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8443 wxPyEndAllowThreads(__tstate);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_Py_Void();
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj = 0;
8455 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8456 int arg2 ;
8457 int arg3 ;
8458 double arg4 ;
8459 void *argp1 = 0 ;
8460 int res1 = 0 ;
8461 int val2 ;
8462 int ecode2 = 0 ;
8463 int val3 ;
8464 int ecode3 = 0 ;
8465 double val4 ;
8466 int ecode4 = 0 ;
8467 PyObject * obj0 = 0 ;
8468 PyObject * obj1 = 0 ;
8469 PyObject * obj2 = 0 ;
8470 PyObject * obj3 = 0 ;
8471 char * kwnames[] = {
8472 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8473 };
8474
8475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8479 }
8480 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8481 ecode2 = SWIG_AsVal_int(obj1, &val2);
8482 if (!SWIG_IsOK(ecode2)) {
8483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8484 }
8485 arg2 = static_cast< int >(val2);
8486 ecode3 = SWIG_AsVal_int(obj2, &val3);
8487 if (!SWIG_IsOK(ecode3)) {
8488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8489 }
8490 arg3 = static_cast< int >(val3);
8491 ecode4 = SWIG_AsVal_double(obj3, &val4);
8492 if (!SWIG_IsOK(ecode4)) {
8493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8494 }
8495 arg4 = static_cast< double >(val4);
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_Py_Void();
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8512 int arg2 ;
8513 int arg3 ;
8514 bool arg4 ;
8515 void *argp1 = 0 ;
8516 int res1 = 0 ;
8517 int val2 ;
8518 int ecode2 = 0 ;
8519 int val3 ;
8520 int ecode3 = 0 ;
8521 bool val4 ;
8522 int ecode4 = 0 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 PyObject * obj2 = 0 ;
8526 PyObject * obj3 = 0 ;
8527 char * kwnames[] = {
8528 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8529 };
8530
8531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8535 }
8536 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8537 ecode2 = SWIG_AsVal_int(obj1, &val2);
8538 if (!SWIG_IsOK(ecode2)) {
8539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8540 }
8541 arg2 = static_cast< int >(val2);
8542 ecode3 = SWIG_AsVal_int(obj2, &val3);
8543 if (!SWIG_IsOK(ecode3)) {
8544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8545 }
8546 arg3 = static_cast< int >(val3);
8547 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8548 if (!SWIG_IsOK(ecode4)) {
8549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8550 }
8551 arg4 = static_cast< bool >(val4);
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8555 wxPyEndAllowThreads(__tstate);
8556 if (PyErr_Occurred()) SWIG_fail;
8557 }
8558 resultobj = SWIG_Py_Void();
8559 return resultobj;
8560 fail:
8561 return NULL;
8562 }
8563
8564
8565 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8566 PyObject *resultobj = 0;
8567 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8568 void *argp1 = 0 ;
8569 int res1 = 0 ;
8570 PyObject *swig_obj[1] ;
8571
8572 if (!args) SWIG_fail;
8573 swig_obj[0] = args;
8574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8577 }
8578 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 (arg1)->Clear();
8582 wxPyEndAllowThreads(__tstate);
8583 if (PyErr_Occurred()) SWIG_fail;
8584 }
8585 resultobj = SWIG_Py_Void();
8586 return resultobj;
8587 fail:
8588 return NULL;
8589 }
8590
8591
8592 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8593 PyObject *resultobj = 0;
8594 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8595 size_t arg2 = (size_t) 0 ;
8596 size_t arg3 = (size_t) 1 ;
8597 bool result;
8598 void *argp1 = 0 ;
8599 int res1 = 0 ;
8600 size_t val2 ;
8601 int ecode2 = 0 ;
8602 size_t val3 ;
8603 int ecode3 = 0 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 PyObject * obj2 = 0 ;
8607 char * kwnames[] = {
8608 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8609 };
8610
8611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8615 }
8616 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8617 if (obj1) {
8618 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8619 if (!SWIG_IsOK(ecode2)) {
8620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8621 }
8622 arg2 = static_cast< size_t >(val2);
8623 }
8624 if (obj2) {
8625 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8626 if (!SWIG_IsOK(ecode3)) {
8627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8628 }
8629 arg3 = static_cast< size_t >(val3);
8630 }
8631 {
8632 PyThreadState* __tstate = wxPyBeginAllowThreads();
8633 result = (bool)(arg1)->InsertRows(arg2,arg3);
8634 wxPyEndAllowThreads(__tstate);
8635 if (PyErr_Occurred()) SWIG_fail;
8636 }
8637 {
8638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8639 }
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj = 0;
8648 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8649 size_t arg2 = (size_t) 1 ;
8650 bool result;
8651 void *argp1 = 0 ;
8652 int res1 = 0 ;
8653 size_t val2 ;
8654 int ecode2 = 0 ;
8655 PyObject * obj0 = 0 ;
8656 PyObject * obj1 = 0 ;
8657 char * kwnames[] = {
8658 (char *) "self",(char *) "numRows", NULL
8659 };
8660
8661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8663 if (!SWIG_IsOK(res1)) {
8664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8665 }
8666 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8667 if (obj1) {
8668 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8669 if (!SWIG_IsOK(ecode2)) {
8670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8671 }
8672 arg2 = static_cast< size_t >(val2);
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 result = (bool)(arg1)->AppendRows(arg2);
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8682 }
8683 return resultobj;
8684 fail:
8685 return NULL;
8686 }
8687
8688
8689 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj = 0;
8691 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8692 size_t arg2 = (size_t) 0 ;
8693 size_t arg3 = (size_t) 1 ;
8694 bool result;
8695 void *argp1 = 0 ;
8696 int res1 = 0 ;
8697 size_t val2 ;
8698 int ecode2 = 0 ;
8699 size_t val3 ;
8700 int ecode3 = 0 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 PyObject * obj2 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8712 }
8713 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8714 if (obj1) {
8715 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8716 if (!SWIG_IsOK(ecode2)) {
8717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8718 }
8719 arg2 = static_cast< size_t >(val2);
8720 }
8721 if (obj2) {
8722 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8723 if (!SWIG_IsOK(ecode3)) {
8724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8725 }
8726 arg3 = static_cast< size_t >(val3);
8727 }
8728 {
8729 PyThreadState* __tstate = wxPyBeginAllowThreads();
8730 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 {
8735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8736 }
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj = 0;
8745 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8746 size_t arg2 = (size_t) 0 ;
8747 size_t arg3 = (size_t) 1 ;
8748 bool result;
8749 void *argp1 = 0 ;
8750 int res1 = 0 ;
8751 size_t val2 ;
8752 int ecode2 = 0 ;
8753 size_t val3 ;
8754 int ecode3 = 0 ;
8755 PyObject * obj0 = 0 ;
8756 PyObject * obj1 = 0 ;
8757 PyObject * obj2 = 0 ;
8758 char * kwnames[] = {
8759 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8760 };
8761
8762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8764 if (!SWIG_IsOK(res1)) {
8765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8766 }
8767 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8768 if (obj1) {
8769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8770 if (!SWIG_IsOK(ecode2)) {
8771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8772 }
8773 arg2 = static_cast< size_t >(val2);
8774 }
8775 if (obj2) {
8776 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8777 if (!SWIG_IsOK(ecode3)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8779 }
8780 arg3 = static_cast< size_t >(val3);
8781 }
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 result = (bool)(arg1)->InsertCols(arg2,arg3);
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 {
8789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8790 }
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8800 size_t arg2 = (size_t) 1 ;
8801 bool result;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 size_t val2 ;
8805 int ecode2 = 0 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "self",(char *) "numCols", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8814 if (!SWIG_IsOK(res1)) {
8815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8816 }
8817 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8818 if (obj1) {
8819 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8820 if (!SWIG_IsOK(ecode2)) {
8821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8822 }
8823 arg2 = static_cast< size_t >(val2);
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 result = (bool)(arg1)->AppendCols(arg2);
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 {
8832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8833 }
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj = 0;
8842 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8843 size_t arg2 = (size_t) 0 ;
8844 size_t arg3 = (size_t) 1 ;
8845 bool result;
8846 void *argp1 = 0 ;
8847 int res1 = 0 ;
8848 size_t val2 ;
8849 int ecode2 = 0 ;
8850 size_t val3 ;
8851 int ecode3 = 0 ;
8852 PyObject * obj0 = 0 ;
8853 PyObject * obj1 = 0 ;
8854 PyObject * obj2 = 0 ;
8855 char * kwnames[] = {
8856 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8857 };
8858
8859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8863 }
8864 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8865 if (obj1) {
8866 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8867 if (!SWIG_IsOK(ecode2)) {
8868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8869 }
8870 arg2 = static_cast< size_t >(val2);
8871 }
8872 if (obj2) {
8873 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8874 if (!SWIG_IsOK(ecode3)) {
8875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8876 }
8877 arg3 = static_cast< size_t >(val3);
8878 }
8879 {
8880 PyThreadState* __tstate = wxPyBeginAllowThreads();
8881 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 {
8886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8887 }
8888 return resultobj;
8889 fail:
8890 return NULL;
8891 }
8892
8893
8894 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8895 PyObject *resultobj = 0;
8896 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8897 int arg2 ;
8898 wxString result;
8899 void *argp1 = 0 ;
8900 int res1 = 0 ;
8901 int val2 ;
8902 int ecode2 = 0 ;
8903 PyObject * obj0 = 0 ;
8904 PyObject * obj1 = 0 ;
8905 char * kwnames[] = {
8906 (char *) "self",(char *) "row", NULL
8907 };
8908
8909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8911 if (!SWIG_IsOK(res1)) {
8912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8913 }
8914 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8915 ecode2 = SWIG_AsVal_int(obj1, &val2);
8916 if (!SWIG_IsOK(ecode2)) {
8917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8918 }
8919 arg2 = static_cast< int >(val2);
8920 {
8921 PyThreadState* __tstate = wxPyBeginAllowThreads();
8922 result = (arg1)->GetRowLabelValue(arg2);
8923 wxPyEndAllowThreads(__tstate);
8924 if (PyErr_Occurred()) SWIG_fail;
8925 }
8926 {
8927 #if wxUSE_UNICODE
8928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8929 #else
8930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8931 #endif
8932 }
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8940 PyObject *resultobj = 0;
8941 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8942 int arg2 ;
8943 wxString result;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 int val2 ;
8947 int ecode2 = 0 ;
8948 PyObject * obj0 = 0 ;
8949 PyObject * obj1 = 0 ;
8950 char * kwnames[] = {
8951 (char *) "self",(char *) "col", NULL
8952 };
8953
8954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8956 if (!SWIG_IsOK(res1)) {
8957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8958 }
8959 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8960 ecode2 = SWIG_AsVal_int(obj1, &val2);
8961 if (!SWIG_IsOK(ecode2)) {
8962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8963 }
8964 arg2 = static_cast< int >(val2);
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 result = (arg1)->GetColLabelValue(arg2);
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 {
8972 #if wxUSE_UNICODE
8973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8974 #else
8975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8976 #endif
8977 }
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj = 0;
8986 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8987 int arg2 ;
8988 wxString *arg3 = 0 ;
8989 void *argp1 = 0 ;
8990 int res1 = 0 ;
8991 int val2 ;
8992 int ecode2 = 0 ;
8993 bool temp3 = false ;
8994 PyObject * obj0 = 0 ;
8995 PyObject * obj1 = 0 ;
8996 PyObject * obj2 = 0 ;
8997 char * kwnames[] = {
8998 (char *) "self",(char *) "row",(char *) "value", NULL
8999 };
9000
9001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9005 }
9006 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9007 ecode2 = SWIG_AsVal_int(obj1, &val2);
9008 if (!SWIG_IsOK(ecode2)) {
9009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9010 }
9011 arg2 = static_cast< int >(val2);
9012 {
9013 arg3 = wxString_in_helper(obj2);
9014 if (arg3 == NULL) SWIG_fail;
9015 temp3 = true;
9016 }
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_Py_Void();
9024 {
9025 if (temp3)
9026 delete arg3;
9027 }
9028 return resultobj;
9029 fail:
9030 {
9031 if (temp3)
9032 delete arg3;
9033 }
9034 return NULL;
9035 }
9036
9037
9038 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj = 0;
9040 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9041 int arg2 ;
9042 wxString *arg3 = 0 ;
9043 void *argp1 = 0 ;
9044 int res1 = 0 ;
9045 int val2 ;
9046 int ecode2 = 0 ;
9047 bool temp3 = false ;
9048 PyObject * obj0 = 0 ;
9049 PyObject * obj1 = 0 ;
9050 PyObject * obj2 = 0 ;
9051 char * kwnames[] = {
9052 (char *) "self",(char *) "col",(char *) "value", NULL
9053 };
9054
9055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9059 }
9060 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9061 ecode2 = SWIG_AsVal_int(obj1, &val2);
9062 if (!SWIG_IsOK(ecode2)) {
9063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9064 }
9065 arg2 = static_cast< int >(val2);
9066 {
9067 arg3 = wxString_in_helper(obj2);
9068 if (arg3 == NULL) SWIG_fail;
9069 temp3 = true;
9070 }
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 resultobj = SWIG_Py_Void();
9078 {
9079 if (temp3)
9080 delete arg3;
9081 }
9082 return resultobj;
9083 fail:
9084 {
9085 if (temp3)
9086 delete arg3;
9087 }
9088 return NULL;
9089 }
9090
9091
9092 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9093 PyObject *resultobj = 0;
9094 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9095 bool result;
9096 void *argp1 = 0 ;
9097 int res1 = 0 ;
9098 PyObject *swig_obj[1] ;
9099
9100 if (!args) SWIG_fail;
9101 swig_obj[0] = args;
9102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9103 if (!SWIG_IsOK(res1)) {
9104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9105 }
9106 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 result = (bool)(arg1)->CanHaveAttributes();
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 {
9114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9115 }
9116 return resultobj;
9117 fail:
9118 return NULL;
9119 }
9120
9121
9122 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9123 PyObject *resultobj = 0;
9124 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9125 int arg2 ;
9126 int arg3 ;
9127 wxGridCellAttr::wxAttrKind arg4 ;
9128 wxGridCellAttr *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 int val2 ;
9132 int ecode2 = 0 ;
9133 int val3 ;
9134 int ecode3 = 0 ;
9135 int val4 ;
9136 int ecode4 = 0 ;
9137 PyObject * obj0 = 0 ;
9138 PyObject * obj1 = 0 ;
9139 PyObject * obj2 = 0 ;
9140 PyObject * obj3 = 0 ;
9141 char * kwnames[] = {
9142 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9143 };
9144
9145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9147 if (!SWIG_IsOK(res1)) {
9148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9149 }
9150 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9151 ecode2 = SWIG_AsVal_int(obj1, &val2);
9152 if (!SWIG_IsOK(ecode2)) {
9153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9154 }
9155 arg2 = static_cast< int >(val2);
9156 ecode3 = SWIG_AsVal_int(obj2, &val3);
9157 if (!SWIG_IsOK(ecode3)) {
9158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9159 }
9160 arg3 = static_cast< int >(val3);
9161 ecode4 = SWIG_AsVal_int(obj3, &val4);
9162 if (!SWIG_IsOK(ecode4)) {
9163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9164 }
9165 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 {
9173 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9174 }
9175 return resultobj;
9176 fail:
9177 return NULL;
9178 }
9179
9180
9181 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = 0;
9183 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9184 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9185 int arg3 ;
9186 int arg4 ;
9187 void *argp1 = 0 ;
9188 int res1 = 0 ;
9189 void *argp2 = 0 ;
9190 int res2 = 0 ;
9191 int val3 ;
9192 int ecode3 = 0 ;
9193 int val4 ;
9194 int ecode4 = 0 ;
9195 PyObject * obj0 = 0 ;
9196 PyObject * obj1 = 0 ;
9197 PyObject * obj2 = 0 ;
9198 PyObject * obj3 = 0 ;
9199 char * kwnames[] = {
9200 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9201 };
9202
9203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9205 if (!SWIG_IsOK(res1)) {
9206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9207 }
9208 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9210 if (!SWIG_IsOK(res2)) {
9211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9212 }
9213 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9214 ecode3 = SWIG_AsVal_int(obj2, &val3);
9215 if (!SWIG_IsOK(ecode3)) {
9216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9217 }
9218 arg3 = static_cast< int >(val3);
9219 ecode4 = SWIG_AsVal_int(obj3, &val4);
9220 if (!SWIG_IsOK(ecode4)) {
9221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9222 }
9223 arg4 = static_cast< int >(val4);
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 (arg1)->SetAttr(arg2,arg3,arg4);
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_Py_Void();
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9238 PyObject *resultobj = 0;
9239 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9240 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9241 int arg3 ;
9242 void *argp1 = 0 ;
9243 int res1 = 0 ;
9244 void *argp2 = 0 ;
9245 int res2 = 0 ;
9246 int val3 ;
9247 int ecode3 = 0 ;
9248 PyObject * obj0 = 0 ;
9249 PyObject * obj1 = 0 ;
9250 PyObject * obj2 = 0 ;
9251 char * kwnames[] = {
9252 (char *) "self",(char *) "attr",(char *) "row", NULL
9253 };
9254
9255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9257 if (!SWIG_IsOK(res1)) {
9258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9259 }
9260 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9262 if (!SWIG_IsOK(res2)) {
9263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9264 }
9265 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9266 ecode3 = SWIG_AsVal_int(obj2, &val3);
9267 if (!SWIG_IsOK(ecode3)) {
9268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9269 }
9270 arg3 = static_cast< int >(val3);
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 (arg1)->SetRowAttr(arg2,arg3);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_Py_Void();
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj = 0;
9286 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9287 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9288 int arg3 ;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 void *argp2 = 0 ;
9292 int res2 = 0 ;
9293 int val3 ;
9294 int ecode3 = 0 ;
9295 PyObject * obj0 = 0 ;
9296 PyObject * obj1 = 0 ;
9297 PyObject * obj2 = 0 ;
9298 char * kwnames[] = {
9299 (char *) "self",(char *) "attr",(char *) "col", NULL
9300 };
9301
9302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9304 if (!SWIG_IsOK(res1)) {
9305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9306 }
9307 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9309 if (!SWIG_IsOK(res2)) {
9310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9311 }
9312 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->SetColAttr(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *obj;
9333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9334 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9335 return SWIG_Py_Void();
9336 }
9337
9338 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *resultobj = 0;
9340 wxPyGridTableBase *result = 0 ;
9341
9342 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9357 PyObject *resultobj = 0;
9358 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9359 PyObject *arg2 = (PyObject *) 0 ;
9360 PyObject *arg3 = (PyObject *) 0 ;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 PyObject * obj2 = 0 ;
9366 char * kwnames[] = {
9367 (char *) "self",(char *) "self",(char *) "_class", NULL
9368 };
9369
9370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9372 if (!SWIG_IsOK(res1)) {
9373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9374 }
9375 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9376 arg2 = obj1;
9377 arg3 = obj2;
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 (arg1)->_setCallbackInfo(arg2,arg3);
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 resultobj = SWIG_Py_Void();
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9392 PyObject *resultobj = 0;
9393 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9394 void *argp1 = 0 ;
9395 int res1 = 0 ;
9396 PyObject *swig_obj[1] ;
9397
9398 if (!args) SWIG_fail;
9399 swig_obj[0] = args;
9400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9401 if (!SWIG_IsOK(res1)) {
9402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9403 }
9404 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9405 {
9406 PyThreadState* __tstate = wxPyBeginAllowThreads();
9407 wxPyGridTableBase_Destroy(arg1);
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_Py_Void();
9412 return resultobj;
9413 fail:
9414 return NULL;
9415 }
9416
9417
9418 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 PyObject *obj;
9420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9421 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9422 return SWIG_Py_Void();
9423 }
9424
9425 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 return SWIG_Python_InitShadowInstance(args);
9427 }
9428
9429 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 int arg1 = (int) 0 ;
9432 int arg2 = (int) 0 ;
9433 wxGridStringTable *result = 0 ;
9434 int val1 ;
9435 int ecode1 = 0 ;
9436 int val2 ;
9437 int ecode2 = 0 ;
9438 PyObject * obj0 = 0 ;
9439 PyObject * obj1 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "numRows",(char *) "numCols", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9445 if (obj0) {
9446 ecode1 = SWIG_AsVal_int(obj0, &val1);
9447 if (!SWIG_IsOK(ecode1)) {
9448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9449 }
9450 arg1 = static_cast< int >(val1);
9451 }
9452 if (obj1) {
9453 ecode2 = SWIG_AsVal_int(obj1, &val2);
9454 if (!SWIG_IsOK(ecode2)) {
9455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9456 }
9457 arg2 = static_cast< int >(val2);
9458 }
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9473 PyObject *obj;
9474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9475 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9476 return SWIG_Py_Void();
9477 }
9478
9479 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9480 return SWIG_Python_InitShadowInstance(args);
9481 }
9482
9483 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj = 0;
9485 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9486 int arg2 ;
9487 int arg3 = (int) -1 ;
9488 int arg4 = (int) -1 ;
9489 wxGridTableMessage *result = 0 ;
9490 void *argp1 = 0 ;
9491 int res1 = 0 ;
9492 int val2 ;
9493 int ecode2 = 0 ;
9494 int val3 ;
9495 int ecode3 = 0 ;
9496 int val4 ;
9497 int ecode4 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 PyObject * obj3 = 0 ;
9502 char * kwnames[] = {
9503 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9504 };
9505
9506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9510 }
9511 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9512 ecode2 = SWIG_AsVal_int(obj1, &val2);
9513 if (!SWIG_IsOK(ecode2)) {
9514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9515 }
9516 arg2 = static_cast< int >(val2);
9517 if (obj2) {
9518 ecode3 = SWIG_AsVal_int(obj2, &val3);
9519 if (!SWIG_IsOK(ecode3)) {
9520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9521 }
9522 arg3 = static_cast< int >(val3);
9523 }
9524 if (obj3) {
9525 ecode4 = SWIG_AsVal_int(obj3, &val4);
9526 if (!SWIG_IsOK(ecode4)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9528 }
9529 arg4 = static_cast< int >(val4);
9530 }
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9545 PyObject *resultobj = 0;
9546 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 PyObject *swig_obj[1] ;
9550
9551 if (!args) SWIG_fail;
9552 swig_obj[0] = args;
9553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9554 if (!SWIG_IsOK(res1)) {
9555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9556 }
9557 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9558 {
9559 PyThreadState* __tstate = wxPyBeginAllowThreads();
9560 delete arg1;
9561
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_Py_Void();
9566 return resultobj;
9567 fail:
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj = 0;
9574 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9575 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9576 void *argp1 = 0 ;
9577 int res1 = 0 ;
9578 void *argp2 = 0 ;
9579 int res2 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 char * kwnames[] = {
9583 (char *) "self",(char *) "table", NULL
9584 };
9585
9586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9588 if (!SWIG_IsOK(res1)) {
9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9590 }
9591 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9592 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9593 if (!SWIG_IsOK(res2)) {
9594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9595 }
9596 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->SetTableObject(arg2);
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_Py_Void();
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *resultobj = 0;
9612 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9613 wxGridTableBase *result = 0 ;
9614 void *argp1 = 0 ;
9615 int res1 = 0 ;
9616 PyObject *swig_obj[1] ;
9617
9618 if (!args) SWIG_fail;
9619 swig_obj[0] = args;
9620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9621 if (!SWIG_IsOK(res1)) {
9622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9623 }
9624 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 {
9632 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9633 }
9634 return resultobj;
9635 fail:
9636 return NULL;
9637 }
9638
9639
9640 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9641 PyObject *resultobj = 0;
9642 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9643 int arg2 ;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 int val2 ;
9647 int ecode2 = 0 ;
9648 PyObject * obj0 = 0 ;
9649 PyObject * obj1 = 0 ;
9650 char * kwnames[] = {
9651 (char *) "self",(char *) "id", NULL
9652 };
9653
9654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9656 if (!SWIG_IsOK(res1)) {
9657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9658 }
9659 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9660 ecode2 = SWIG_AsVal_int(obj1, &val2);
9661 if (!SWIG_IsOK(ecode2)) {
9662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9663 }
9664 arg2 = static_cast< int >(val2);
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 (arg1)->SetId(arg2);
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 resultobj = SWIG_Py_Void();
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679 PyObject *resultobj = 0;
9680 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9681 int result;
9682 void *argp1 = 0 ;
9683 int res1 = 0 ;
9684 PyObject *swig_obj[1] ;
9685
9686 if (!args) SWIG_fail;
9687 swig_obj[0] = args;
9688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9691 }
9692 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9693 {
9694 PyThreadState* __tstate = wxPyBeginAllowThreads();
9695 result = (int)(arg1)->GetId();
9696 wxPyEndAllowThreads(__tstate);
9697 if (PyErr_Occurred()) SWIG_fail;
9698 }
9699 resultobj = SWIG_From_int(static_cast< int >(result));
9700 return resultobj;
9701 fail:
9702 return NULL;
9703 }
9704
9705
9706 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9707 PyObject *resultobj = 0;
9708 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9709 int arg2 ;
9710 void *argp1 = 0 ;
9711 int res1 = 0 ;
9712 int val2 ;
9713 int ecode2 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 char * kwnames[] = {
9717 (char *) "self",(char *) "comInt1", NULL
9718 };
9719
9720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9722 if (!SWIG_IsOK(res1)) {
9723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9724 }
9725 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9726 ecode2 = SWIG_AsVal_int(obj1, &val2);
9727 if (!SWIG_IsOK(ecode2)) {
9728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9729 }
9730 arg2 = static_cast< int >(val2);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 (arg1)->SetCommandInt(arg2);
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_Py_Void();
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9747 int result;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 PyObject *swig_obj[1] ;
9751
9752 if (!args) SWIG_fail;
9753 swig_obj[0] = args;
9754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9755 if (!SWIG_IsOK(res1)) {
9756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9757 }
9758 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 result = (int)(arg1)->GetCommandInt();
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_From_int(static_cast< int >(result));
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9775 int arg2 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 int val2 ;
9779 int ecode2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "comInt2", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9790 }
9791 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9792 ecode2 = SWIG_AsVal_int(obj1, &val2);
9793 if (!SWIG_IsOK(ecode2)) {
9794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9795 }
9796 arg2 = static_cast< int >(val2);
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 (arg1)->SetCommandInt2(arg2);
9800 wxPyEndAllowThreads(__tstate);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 resultobj = SWIG_Py_Void();
9804 return resultobj;
9805 fail:
9806 return NULL;
9807 }
9808
9809
9810 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9811 PyObject *resultobj = 0;
9812 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9813 int result;
9814 void *argp1 = 0 ;
9815 int res1 = 0 ;
9816 PyObject *swig_obj[1] ;
9817
9818 if (!args) SWIG_fail;
9819 swig_obj[0] = args;
9820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9821 if (!SWIG_IsOK(res1)) {
9822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9823 }
9824 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9825 {
9826 PyThreadState* __tstate = wxPyBeginAllowThreads();
9827 result = (int)(arg1)->GetCommandInt2();
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 resultobj = SWIG_From_int(static_cast< int >(result));
9832 return resultobj;
9833 fail:
9834 return NULL;
9835 }
9836
9837
9838 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9839 PyObject *obj;
9840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9841 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9842 return SWIG_Py_Void();
9843 }
9844
9845 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 return SWIG_Python_InitShadowInstance(args);
9847 }
9848
9849 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9850 PyObject *resultobj = 0;
9851 int arg1 = (int) -1 ;
9852 int arg2 = (int) -1 ;
9853 wxGridCellCoords *result = 0 ;
9854 int val1 ;
9855 int ecode1 = 0 ;
9856 int val2 ;
9857 int ecode2 = 0 ;
9858 PyObject * obj0 = 0 ;
9859 PyObject * obj1 = 0 ;
9860 char * kwnames[] = {
9861 (char *) "r",(char *) "c", NULL
9862 };
9863
9864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9865 if (obj0) {
9866 ecode1 = SWIG_AsVal_int(obj0, &val1);
9867 if (!SWIG_IsOK(ecode1)) {
9868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9869 }
9870 arg1 = static_cast< int >(val1);
9871 }
9872 if (obj1) {
9873 ecode2 = SWIG_AsVal_int(obj1, &val2);
9874 if (!SWIG_IsOK(ecode2)) {
9875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9876 }
9877 arg2 = static_cast< int >(val2);
9878 }
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9893 PyObject *resultobj = 0;
9894 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9895 void *argp1 = 0 ;
9896 int res1 = 0 ;
9897 PyObject *swig_obj[1] ;
9898
9899 if (!args) SWIG_fail;
9900 swig_obj[0] = args;
9901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9902 if (!SWIG_IsOK(res1)) {
9903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9904 }
9905 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9906 {
9907 PyThreadState* __tstate = wxPyBeginAllowThreads();
9908 delete arg1;
9909
9910 wxPyEndAllowThreads(__tstate);
9911 if (PyErr_Occurred()) SWIG_fail;
9912 }
9913 resultobj = SWIG_Py_Void();
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9921 PyObject *resultobj = 0;
9922 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9923 int result;
9924 void *argp1 = 0 ;
9925 int res1 = 0 ;
9926 PyObject *swig_obj[1] ;
9927
9928 if (!args) SWIG_fail;
9929 swig_obj[0] = args;
9930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9931 if (!SWIG_IsOK(res1)) {
9932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9933 }
9934 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9935 {
9936 PyThreadState* __tstate = wxPyBeginAllowThreads();
9937 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9938 wxPyEndAllowThreads(__tstate);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 resultobj = SWIG_From_int(static_cast< int >(result));
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj = 0;
9950 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9951 int arg2 ;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 int val2 ;
9955 int ecode2 = 0 ;
9956 PyObject * obj0 = 0 ;
9957 PyObject * obj1 = 0 ;
9958 char * kwnames[] = {
9959 (char *) "self",(char *) "n", NULL
9960 };
9961
9962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9964 if (!SWIG_IsOK(res1)) {
9965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9966 }
9967 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9968 ecode2 = SWIG_AsVal_int(obj1, &val2);
9969 if (!SWIG_IsOK(ecode2)) {
9970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9971 }
9972 arg2 = static_cast< int >(val2);
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 (arg1)->SetRow(arg2);
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 resultobj = SWIG_Py_Void();
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9987 PyObject *resultobj = 0;
9988 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9989 int result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 PyObject *swig_obj[1] ;
9993
9994 if (!args) SWIG_fail;
9995 swig_obj[0] = args;
9996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9997 if (!SWIG_IsOK(res1)) {
9998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9999 }
10000 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10004 wxPyEndAllowThreads(__tstate);
10005 if (PyErr_Occurred()) SWIG_fail;
10006 }
10007 resultobj = SWIG_From_int(static_cast< int >(result));
10008 return resultobj;
10009 fail:
10010 return NULL;
10011 }
10012
10013
10014 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10015 PyObject *resultobj = 0;
10016 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10017 int arg2 ;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 int val2 ;
10021 int ecode2 = 0 ;
10022 PyObject * obj0 = 0 ;
10023 PyObject * obj1 = 0 ;
10024 char * kwnames[] = {
10025 (char *) "self",(char *) "n", NULL
10026 };
10027
10028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10032 }
10033 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10034 ecode2 = SWIG_AsVal_int(obj1, &val2);
10035 if (!SWIG_IsOK(ecode2)) {
10036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10037 }
10038 arg2 = static_cast< int >(val2);
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 (arg1)->SetCol(arg2);
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 resultobj = SWIG_Py_Void();
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
10052 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10053 PyObject *resultobj = 0;
10054 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10055 int arg2 ;
10056 int arg3 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 int val2 ;
10060 int ecode2 = 0 ;
10061 int val3 ;
10062 int ecode3 = 0 ;
10063 PyObject * obj0 = 0 ;
10064 PyObject * obj1 = 0 ;
10065 PyObject * obj2 = 0 ;
10066 char * kwnames[] = {
10067 (char *) "self",(char *) "row",(char *) "col", NULL
10068 };
10069
10070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10072 if (!SWIG_IsOK(res1)) {
10073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10074 }
10075 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10076 ecode2 = SWIG_AsVal_int(obj1, &val2);
10077 if (!SWIG_IsOK(ecode2)) {
10078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10079 }
10080 arg2 = static_cast< int >(val2);
10081 ecode3 = SWIG_AsVal_int(obj2, &val3);
10082 if (!SWIG_IsOK(ecode3)) {
10083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10084 }
10085 arg3 = static_cast< int >(val3);
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 (arg1)->Set(arg2,arg3);
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 resultobj = SWIG_Py_Void();
10093 return resultobj;
10094 fail:
10095 return NULL;
10096 }
10097
10098
10099 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj = 0;
10101 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10102 PyObject *arg2 = (PyObject *) 0 ;
10103 bool result;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "other", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10116 }
10117 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10118 arg2 = obj1;
10119 {
10120 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 {
10124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10125 }
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj = 0;
10134 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10135 PyObject *arg2 = (PyObject *) 0 ;
10136 bool result;
10137 void *argp1 = 0 ;
10138 int res1 = 0 ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char * kwnames[] = {
10142 (char *) "self",(char *) "other", NULL
10143 };
10144
10145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10149 }
10150 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10151 arg2 = obj1;
10152 {
10153 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 {
10157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 PyObject *resultobj = 0;
10167 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10168 PyObject *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 PyObject *swig_obj[1] ;
10172
10173 if (!args) SWIG_fail;
10174 swig_obj[0] = args;
10175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10178 }
10179 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 result = (PyObject *)wxGridCellCoords_Get(arg1);
10183 wxPyEndAllowThreads(__tstate);
10184 if (PyErr_Occurred()) SWIG_fail;
10185 }
10186 resultobj = result;
10187 return resultobj;
10188 fail:
10189 return NULL;
10190 }
10191
10192
10193 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10194 PyObject *obj;
10195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10196 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10197 return SWIG_Py_Void();
10198 }
10199
10200 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10201 return SWIG_Python_InitShadowInstance(args);
10202 }
10203
10204 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj = 0;
10206 wxWindow *arg1 = (wxWindow *) 0 ;
10207 int arg2 = (int) -1 ;
10208 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10209 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10210 wxSize const &arg4_defvalue = wxDefaultSize ;
10211 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10212 long arg5 = (long) wxWANTS_CHARS ;
10213 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10214 wxString *arg6 = (wxString *) &arg6_defvalue ;
10215 wxGrid *result = 0 ;
10216 void *argp1 = 0 ;
10217 int res1 = 0 ;
10218 int val2 ;
10219 int ecode2 = 0 ;
10220 wxPoint temp3 ;
10221 wxSize temp4 ;
10222 long val5 ;
10223 int ecode5 = 0 ;
10224 bool temp6 = false ;
10225 PyObject * obj0 = 0 ;
10226 PyObject * obj1 = 0 ;
10227 PyObject * obj2 = 0 ;
10228 PyObject * obj3 = 0 ;
10229 PyObject * obj4 = 0 ;
10230 PyObject * obj5 = 0 ;
10231 char * kwnames[] = {
10232 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10233 };
10234
10235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10237 if (!SWIG_IsOK(res1)) {
10238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10239 }
10240 arg1 = reinterpret_cast< wxWindow * >(argp1);
10241 if (obj1) {
10242 ecode2 = SWIG_AsVal_int(obj1, &val2);
10243 if (!SWIG_IsOK(ecode2)) {
10244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10245 }
10246 arg2 = static_cast< int >(val2);
10247 }
10248 if (obj2) {
10249 {
10250 arg3 = &temp3;
10251 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10252 }
10253 }
10254 if (obj3) {
10255 {
10256 arg4 = &temp4;
10257 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10258 }
10259 }
10260 if (obj4) {
10261 ecode5 = SWIG_AsVal_long(obj4, &val5);
10262 if (!SWIG_IsOK(ecode5)) {
10263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10264 }
10265 arg5 = static_cast< long >(val5);
10266 }
10267 if (obj5) {
10268 {
10269 arg6 = wxString_in_helper(obj5);
10270 if (arg6 == NULL) SWIG_fail;
10271 temp6 = true;
10272 }
10273 }
10274 {
10275 if (!wxPyCheckForApp()) SWIG_fail;
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10282 {
10283 if (temp6)
10284 delete arg6;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp6)
10290 delete arg6;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10297 PyObject *resultobj = 0;
10298 wxGrid *result = 0 ;
10299
10300 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10301 {
10302 if (!wxPyCheckForApp()) SWIG_fail;
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 result = (wxGrid *)new wxGrid();
10305 wxPyEndAllowThreads(__tstate);
10306 if (PyErr_Occurred()) SWIG_fail;
10307 }
10308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10309 return resultobj;
10310 fail:
10311 return NULL;
10312 }
10313
10314
10315 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10316 PyObject *resultobj = 0;
10317 wxGrid *arg1 = (wxGrid *) 0 ;
10318 wxWindow *arg2 = (wxWindow *) 0 ;
10319 int arg3 = (int) -1 ;
10320 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10321 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10322 wxSize const &arg5_defvalue = wxDefaultSize ;
10323 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10324 long arg6 = (long) wxWANTS_CHARS ;
10325 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10326 wxString *arg7 = (wxString *) &arg7_defvalue ;
10327 bool result;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 void *argp2 = 0 ;
10331 int res2 = 0 ;
10332 int val3 ;
10333 int ecode3 = 0 ;
10334 wxPoint temp4 ;
10335 wxSize temp5 ;
10336 long val6 ;
10337 int ecode6 = 0 ;
10338 bool temp7 = false ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 PyObject * obj2 = 0 ;
10342 PyObject * obj3 = 0 ;
10343 PyObject * obj4 = 0 ;
10344 PyObject * obj5 = 0 ;
10345 PyObject * obj6 = 0 ;
10346 char * kwnames[] = {
10347 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10348 };
10349
10350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10352 if (!SWIG_IsOK(res1)) {
10353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10354 }
10355 arg1 = reinterpret_cast< wxGrid * >(argp1);
10356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10357 if (!SWIG_IsOK(res2)) {
10358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10359 }
10360 arg2 = reinterpret_cast< wxWindow * >(argp2);
10361 if (obj2) {
10362 ecode3 = SWIG_AsVal_int(obj2, &val3);
10363 if (!SWIG_IsOK(ecode3)) {
10364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10365 }
10366 arg3 = static_cast< int >(val3);
10367 }
10368 if (obj3) {
10369 {
10370 arg4 = &temp4;
10371 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10372 }
10373 }
10374 if (obj4) {
10375 {
10376 arg5 = &temp5;
10377 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10378 }
10379 }
10380 if (obj5) {
10381 ecode6 = SWIG_AsVal_long(obj5, &val6);
10382 if (!SWIG_IsOK(ecode6)) {
10383 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10384 }
10385 arg6 = static_cast< long >(val6);
10386 }
10387 if (obj6) {
10388 {
10389 arg7 = wxString_in_helper(obj6);
10390 if (arg7 == NULL) SWIG_fail;
10391 temp7 = true;
10392 }
10393 }
10394 {
10395 PyThreadState* __tstate = wxPyBeginAllowThreads();
10396 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10397 wxPyEndAllowThreads(__tstate);
10398 if (PyErr_Occurred()) SWIG_fail;
10399 }
10400 {
10401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10402 }
10403 {
10404 if (temp7)
10405 delete arg7;
10406 }
10407 return resultobj;
10408 fail:
10409 {
10410 if (temp7)
10411 delete arg7;
10412 }
10413 return NULL;
10414 }
10415
10416
10417 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10418 PyObject *resultobj = 0;
10419 wxGrid *arg1 = (wxGrid *) 0 ;
10420 int arg2 ;
10421 int arg3 ;
10422 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10423 bool result;
10424 void *argp1 = 0 ;
10425 int res1 = 0 ;
10426 int val2 ;
10427 int ecode2 = 0 ;
10428 int val3 ;
10429 int ecode3 = 0 ;
10430 int val4 ;
10431 int ecode4 = 0 ;
10432 PyObject * obj0 = 0 ;
10433 PyObject * obj1 = 0 ;
10434 PyObject * obj2 = 0 ;
10435 PyObject * obj3 = 0 ;
10436 char * kwnames[] = {
10437 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10438 };
10439
10440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10442 if (!SWIG_IsOK(res1)) {
10443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10444 }
10445 arg1 = reinterpret_cast< wxGrid * >(argp1);
10446 ecode2 = SWIG_AsVal_int(obj1, &val2);
10447 if (!SWIG_IsOK(ecode2)) {
10448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10449 }
10450 arg2 = static_cast< int >(val2);
10451 ecode3 = SWIG_AsVal_int(obj2, &val3);
10452 if (!SWIG_IsOK(ecode3)) {
10453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10454 }
10455 arg3 = static_cast< int >(val3);
10456 if (obj3) {
10457 ecode4 = SWIG_AsVal_int(obj3, &val4);
10458 if (!SWIG_IsOK(ecode4)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10460 }
10461 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10462 }
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 {
10470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10471 }
10472 return resultobj;
10473 fail:
10474 return NULL;
10475 }
10476
10477
10478 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10479 PyObject *resultobj = 0;
10480 wxGrid *arg1 = (wxGrid *) 0 ;
10481 WXGRIDSELECTIONMODES arg2 ;
10482 void *argp1 = 0 ;
10483 int res1 = 0 ;
10484 int val2 ;
10485 int ecode2 = 0 ;
10486 PyObject * obj0 = 0 ;
10487 PyObject * obj1 = 0 ;
10488 char * kwnames[] = {
10489 (char *) "self",(char *) "selmode", NULL
10490 };
10491
10492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10496 }
10497 arg1 = reinterpret_cast< wxGrid * >(argp1);
10498 ecode2 = SWIG_AsVal_int(obj1, &val2);
10499 if (!SWIG_IsOK(ecode2)) {
10500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10501 }
10502 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 (arg1)->SetSelectionMode(arg2);
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 resultobj = SWIG_Py_Void();
10510 return resultobj;
10511 fail:
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10517 PyObject *resultobj = 0;
10518 wxGrid *arg1 = (wxGrid *) 0 ;
10519 WXGRIDSELECTIONMODES result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 PyObject *swig_obj[1] ;
10523
10524 if (!args) SWIG_fail;
10525 swig_obj[0] = args;
10526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10527 if (!SWIG_IsOK(res1)) {
10528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10529 }
10530 arg1 = reinterpret_cast< wxGrid * >(argp1);
10531 {
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 resultobj = SWIG_From_int(static_cast< int >(result));
10538 return resultobj;
10539 fail:
10540 return NULL;
10541 }
10542
10543
10544 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10545 PyObject *resultobj = 0;
10546 wxGrid *arg1 = (wxGrid *) 0 ;
10547 int result;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 PyObject *swig_obj[1] ;
10551
10552 if (!args) SWIG_fail;
10553 swig_obj[0] = args;
10554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10555 if (!SWIG_IsOK(res1)) {
10556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10557 }
10558 arg1 = reinterpret_cast< wxGrid * >(argp1);
10559 {
10560 PyThreadState* __tstate = wxPyBeginAllowThreads();
10561 result = (int)(arg1)->GetNumberRows();
10562 wxPyEndAllowThreads(__tstate);
10563 if (PyErr_Occurred()) SWIG_fail;
10564 }
10565 resultobj = SWIG_From_int(static_cast< int >(result));
10566 return resultobj;
10567 fail:
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxGrid *arg1 = (wxGrid *) 0 ;
10575 int result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 PyObject *swig_obj[1] ;
10579
10580 if (!args) SWIG_fail;
10581 swig_obj[0] = args;
10582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10585 }
10586 arg1 = reinterpret_cast< wxGrid * >(argp1);
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = (int)(arg1)->GetNumberCols();
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_From_int(static_cast< int >(result));
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = 0;
10602 wxGrid *arg1 = (wxGrid *) 0 ;
10603 wxGridTableMessage *arg2 = 0 ;
10604 bool result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 void *argp2 = 0 ;
10608 int res2 = 0 ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611 char * kwnames[] = {
10612 (char *) "self",(char *)"arg2", NULL
10613 };
10614
10615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10619 }
10620 arg1 = reinterpret_cast< wxGrid * >(argp1);
10621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10622 if (!SWIG_IsOK(res2)) {
10623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10624 }
10625 if (!argp2) {
10626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10627 }
10628 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10629 {
10630 PyThreadState* __tstate = wxPyBeginAllowThreads();
10631 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10632 wxPyEndAllowThreads(__tstate);
10633 if (PyErr_Occurred()) SWIG_fail;
10634 }
10635 {
10636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10637 }
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10645 PyObject *resultobj = 0;
10646 wxGrid *arg1 = (wxGrid *) 0 ;
10647 wxGridTableBase *result = 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 PyObject *swig_obj[1] ;
10651
10652 if (!args) SWIG_fail;
10653 swig_obj[0] = args;
10654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10657 }
10658 arg1 = reinterpret_cast< wxGrid * >(argp1);
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 {
10666 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10667 }
10668 return resultobj;
10669 fail:
10670 return NULL;
10671 }
10672
10673
10674 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10675 PyObject *resultobj = 0;
10676 wxGrid *arg1 = (wxGrid *) 0 ;
10677 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10678 bool arg3 = (bool) false ;
10679 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10680 bool result;
10681 void *argp1 = 0 ;
10682 int res1 = 0 ;
10683 int res2 = 0 ;
10684 bool val3 ;
10685 int ecode3 = 0 ;
10686 int val4 ;
10687 int ecode4 = 0 ;
10688 PyObject * obj0 = 0 ;
10689 PyObject * obj1 = 0 ;
10690 PyObject * obj2 = 0 ;
10691 PyObject * obj3 = 0 ;
10692 char * kwnames[] = {
10693 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10694 };
10695
10696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10698 if (!SWIG_IsOK(res1)) {
10699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10700 }
10701 arg1 = reinterpret_cast< wxGrid * >(argp1);
10702 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10703 if (!SWIG_IsOK(res2)) {
10704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10705 }
10706 if (obj2) {
10707 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10708 if (!SWIG_IsOK(ecode3)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10710 }
10711 arg3 = static_cast< bool >(val3);
10712 }
10713 if (obj3) {
10714 ecode4 = SWIG_AsVal_int(obj3, &val4);
10715 if (!SWIG_IsOK(ecode4)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10717 }
10718 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10719 }
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 {
10727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10728 }
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10736 PyObject *resultobj = 0;
10737 wxGrid *arg1 = (wxGrid *) 0 ;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 PyObject *swig_obj[1] ;
10741
10742 if (!args) SWIG_fail;
10743 swig_obj[0] = args;
10744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10747 }
10748 arg1 = reinterpret_cast< wxGrid * >(argp1);
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 (arg1)->ClearGrid();
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 resultobj = SWIG_Py_Void();
10756 return resultobj;
10757 fail:
10758 return NULL;
10759 }
10760
10761
10762 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10763 PyObject *resultobj = 0;
10764 wxGrid *arg1 = (wxGrid *) 0 ;
10765 int arg2 = (int) 0 ;
10766 int arg3 = (int) 1 ;
10767 bool arg4 = (bool) true ;
10768 bool result;
10769 void *argp1 = 0 ;
10770 int res1 = 0 ;
10771 int val2 ;
10772 int ecode2 = 0 ;
10773 int val3 ;
10774 int ecode3 = 0 ;
10775 bool val4 ;
10776 int ecode4 = 0 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 PyObject * obj2 = 0 ;
10780 PyObject * obj3 = 0 ;
10781 char * kwnames[] = {
10782 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10783 };
10784
10785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10787 if (!SWIG_IsOK(res1)) {
10788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10789 }
10790 arg1 = reinterpret_cast< wxGrid * >(argp1);
10791 if (obj1) {
10792 ecode2 = SWIG_AsVal_int(obj1, &val2);
10793 if (!SWIG_IsOK(ecode2)) {
10794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10795 }
10796 arg2 = static_cast< int >(val2);
10797 }
10798 if (obj2) {
10799 ecode3 = SWIG_AsVal_int(obj2, &val3);
10800 if (!SWIG_IsOK(ecode3)) {
10801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10802 }
10803 arg3 = static_cast< int >(val3);
10804 }
10805 if (obj3) {
10806 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10807 if (!SWIG_IsOK(ecode4)) {
10808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10809 }
10810 arg4 = static_cast< bool >(val4);
10811 }
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 {
10819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10820 }
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxGrid *arg1 = (wxGrid *) 0 ;
10830 int arg2 = (int) 1 ;
10831 bool arg3 = (bool) true ;
10832 bool result;
10833 void *argp1 = 0 ;
10834 int res1 = 0 ;
10835 int val2 ;
10836 int ecode2 = 0 ;
10837 bool val3 ;
10838 int ecode3 = 0 ;
10839 PyObject * obj0 = 0 ;
10840 PyObject * obj1 = 0 ;
10841 PyObject * obj2 = 0 ;
10842 char * kwnames[] = {
10843 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10844 };
10845
10846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10848 if (!SWIG_IsOK(res1)) {
10849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10850 }
10851 arg1 = reinterpret_cast< wxGrid * >(argp1);
10852 if (obj1) {
10853 ecode2 = SWIG_AsVal_int(obj1, &val2);
10854 if (!SWIG_IsOK(ecode2)) {
10855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10856 }
10857 arg2 = static_cast< int >(val2);
10858 }
10859 if (obj2) {
10860 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10861 if (!SWIG_IsOK(ecode3)) {
10862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10863 }
10864 arg3 = static_cast< bool >(val3);
10865 }
10866 {
10867 PyThreadState* __tstate = wxPyBeginAllowThreads();
10868 result = (bool)(arg1)->AppendRows(arg2,arg3);
10869 wxPyEndAllowThreads(__tstate);
10870 if (PyErr_Occurred()) SWIG_fail;
10871 }
10872 {
10873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10874 }
10875 return resultobj;
10876 fail:
10877 return NULL;
10878 }
10879
10880
10881 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10882 PyObject *resultobj = 0;
10883 wxGrid *arg1 = (wxGrid *) 0 ;
10884 int arg2 = (int) 0 ;
10885 int arg3 = (int) 1 ;
10886 bool arg4 = (bool) true ;
10887 bool result;
10888 void *argp1 = 0 ;
10889 int res1 = 0 ;
10890 int val2 ;
10891 int ecode2 = 0 ;
10892 int val3 ;
10893 int ecode3 = 0 ;
10894 bool val4 ;
10895 int ecode4 = 0 ;
10896 PyObject * obj0 = 0 ;
10897 PyObject * obj1 = 0 ;
10898 PyObject * obj2 = 0 ;
10899 PyObject * obj3 = 0 ;
10900 char * kwnames[] = {
10901 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10902 };
10903
10904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10906 if (!SWIG_IsOK(res1)) {
10907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10908 }
10909 arg1 = reinterpret_cast< wxGrid * >(argp1);
10910 if (obj1) {
10911 ecode2 = SWIG_AsVal_int(obj1, &val2);
10912 if (!SWIG_IsOK(ecode2)) {
10913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10914 }
10915 arg2 = static_cast< int >(val2);
10916 }
10917 if (obj2) {
10918 ecode3 = SWIG_AsVal_int(obj2, &val3);
10919 if (!SWIG_IsOK(ecode3)) {
10920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10921 }
10922 arg3 = static_cast< int >(val3);
10923 }
10924 if (obj3) {
10925 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10926 if (!SWIG_IsOK(ecode4)) {
10927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10928 }
10929 arg4 = static_cast< bool >(val4);
10930 }
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10939 }
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = 0;
10948 wxGrid *arg1 = (wxGrid *) 0 ;
10949 int arg2 = (int) 0 ;
10950 int arg3 = (int) 1 ;
10951 bool arg4 = (bool) true ;
10952 bool result;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 int val2 ;
10956 int ecode2 = 0 ;
10957 int val3 ;
10958 int ecode3 = 0 ;
10959 bool val4 ;
10960 int ecode4 = 0 ;
10961 PyObject * obj0 = 0 ;
10962 PyObject * obj1 = 0 ;
10963 PyObject * obj2 = 0 ;
10964 PyObject * obj3 = 0 ;
10965 char * kwnames[] = {
10966 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10967 };
10968
10969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10973 }
10974 arg1 = reinterpret_cast< wxGrid * >(argp1);
10975 if (obj1) {
10976 ecode2 = SWIG_AsVal_int(obj1, &val2);
10977 if (!SWIG_IsOK(ecode2)) {
10978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10979 }
10980 arg2 = static_cast< int >(val2);
10981 }
10982 if (obj2) {
10983 ecode3 = SWIG_AsVal_int(obj2, &val3);
10984 if (!SWIG_IsOK(ecode3)) {
10985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10986 }
10987 arg3 = static_cast< int >(val3);
10988 }
10989 if (obj3) {
10990 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10991 if (!SWIG_IsOK(ecode4)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10993 }
10994 arg4 = static_cast< bool >(val4);
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11004 }
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj = 0;
11013 wxGrid *arg1 = (wxGrid *) 0 ;
11014 int arg2 = (int) 1 ;
11015 bool arg3 = (bool) true ;
11016 bool result;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 int val2 ;
11020 int ecode2 = 0 ;
11021 bool val3 ;
11022 int ecode3 = 0 ;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 PyObject * obj2 = 0 ;
11026 char * kwnames[] = {
11027 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11028 };
11029
11030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11032 if (!SWIG_IsOK(res1)) {
11033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11034 }
11035 arg1 = reinterpret_cast< wxGrid * >(argp1);
11036 if (obj1) {
11037 ecode2 = SWIG_AsVal_int(obj1, &val2);
11038 if (!SWIG_IsOK(ecode2)) {
11039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11040 }
11041 arg2 = static_cast< int >(val2);
11042 }
11043 if (obj2) {
11044 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11045 if (!SWIG_IsOK(ecode3)) {
11046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11047 }
11048 arg3 = static_cast< bool >(val3);
11049 }
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (bool)(arg1)->AppendCols(arg2,arg3);
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11066 PyObject *resultobj = 0;
11067 wxGrid *arg1 = (wxGrid *) 0 ;
11068 int arg2 = (int) 0 ;
11069 int arg3 = (int) 1 ;
11070 bool arg4 = (bool) true ;
11071 bool result;
11072 void *argp1 = 0 ;
11073 int res1 = 0 ;
11074 int val2 ;
11075 int ecode2 = 0 ;
11076 int val3 ;
11077 int ecode3 = 0 ;
11078 bool val4 ;
11079 int ecode4 = 0 ;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 PyObject * obj3 = 0 ;
11084 char * kwnames[] = {
11085 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11086 };
11087
11088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11090 if (!SWIG_IsOK(res1)) {
11091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11092 }
11093 arg1 = reinterpret_cast< wxGrid * >(argp1);
11094 if (obj1) {
11095 ecode2 = SWIG_AsVal_int(obj1, &val2);
11096 if (!SWIG_IsOK(ecode2)) {
11097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11098 }
11099 arg2 = static_cast< int >(val2);
11100 }
11101 if (obj2) {
11102 ecode3 = SWIG_AsVal_int(obj2, &val3);
11103 if (!SWIG_IsOK(ecode3)) {
11104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11105 }
11106 arg3 = static_cast< int >(val3);
11107 }
11108 if (obj3) {
11109 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11110 if (!SWIG_IsOK(ecode4)) {
11111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11112 }
11113 arg4 = static_cast< bool >(val4);
11114 }
11115 {
11116 PyThreadState* __tstate = wxPyBeginAllowThreads();
11117 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
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_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj = 0;
11132 wxGrid *arg1 = (wxGrid *) 0 ;
11133 wxDC *arg2 = 0 ;
11134 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11135 void *argp1 = 0 ;
11136 int res1 = 0 ;
11137 void *argp2 = 0 ;
11138 int res2 = 0 ;
11139 void *argp3 = 0 ;
11140 int res3 = 0 ;
11141 PyObject * obj0 = 0 ;
11142 PyObject * obj1 = 0 ;
11143 PyObject * obj2 = 0 ;
11144 char * kwnames[] = {
11145 (char *) "self",(char *) "dc",(char *) "attr", NULL
11146 };
11147
11148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11152 }
11153 arg1 = reinterpret_cast< wxGrid * >(argp1);
11154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11155 if (!SWIG_IsOK(res2)) {
11156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11157 }
11158 if (!argp2) {
11159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11160 }
11161 arg2 = reinterpret_cast< wxDC * >(argp2);
11162 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11163 if (!SWIG_IsOK(res3)) {
11164 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11165 }
11166 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 resultobj = SWIG_Py_Void();
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj = 0;
11182 wxGrid *arg1 = (wxGrid *) 0 ;
11183 wxDC *arg2 = 0 ;
11184 wxString *arg3 = 0 ;
11185 wxRect *arg4 = 0 ;
11186 int arg5 = (int) wxLEFT ;
11187 int arg6 = (int) wxTOP ;
11188 int arg7 = (int) wxHORIZONTAL ;
11189 void *argp1 = 0 ;
11190 int res1 = 0 ;
11191 void *argp2 = 0 ;
11192 int res2 = 0 ;
11193 bool temp3 = false ;
11194 wxRect temp4 ;
11195 int val5 ;
11196 int ecode5 = 0 ;
11197 int val6 ;
11198 int ecode6 = 0 ;
11199 int val7 ;
11200 int ecode7 = 0 ;
11201 PyObject * obj0 = 0 ;
11202 PyObject * obj1 = 0 ;
11203 PyObject * obj2 = 0 ;
11204 PyObject * obj3 = 0 ;
11205 PyObject * obj4 = 0 ;
11206 PyObject * obj5 = 0 ;
11207 PyObject * obj6 = 0 ;
11208 char * kwnames[] = {
11209 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11210 };
11211
11212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11214 if (!SWIG_IsOK(res1)) {
11215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11216 }
11217 arg1 = reinterpret_cast< wxGrid * >(argp1);
11218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11219 if (!SWIG_IsOK(res2)) {
11220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11221 }
11222 if (!argp2) {
11223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11224 }
11225 arg2 = reinterpret_cast< wxDC * >(argp2);
11226 {
11227 arg3 = wxString_in_helper(obj2);
11228 if (arg3 == NULL) SWIG_fail;
11229 temp3 = true;
11230 }
11231 {
11232 arg4 = &temp4;
11233 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11234 }
11235 if (obj4) {
11236 ecode5 = SWIG_AsVal_int(obj4, &val5);
11237 if (!SWIG_IsOK(ecode5)) {
11238 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11239 }
11240 arg5 = static_cast< int >(val5);
11241 }
11242 if (obj5) {
11243 ecode6 = SWIG_AsVal_int(obj5, &val6);
11244 if (!SWIG_IsOK(ecode6)) {
11245 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11246 }
11247 arg6 = static_cast< int >(val6);
11248 }
11249 if (obj6) {
11250 ecode7 = SWIG_AsVal_int(obj6, &val7);
11251 if (!SWIG_IsOK(ecode7)) {
11252 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11253 }
11254 arg7 = static_cast< int >(val7);
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 resultobj = SWIG_Py_Void();
11263 {
11264 if (temp3)
11265 delete arg3;
11266 }
11267 return resultobj;
11268 fail:
11269 {
11270 if (temp3)
11271 delete arg3;
11272 }
11273 return NULL;
11274 }
11275
11276
11277 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj = 0;
11279 wxGrid *arg1 = (wxGrid *) 0 ;
11280 wxDC *arg2 = 0 ;
11281 wxArrayString *arg3 = 0 ;
11282 long *arg4 = (long *) 0 ;
11283 long *arg5 = (long *) 0 ;
11284 void *argp1 = 0 ;
11285 int res1 = 0 ;
11286 void *argp2 = 0 ;
11287 int res2 = 0 ;
11288 bool temp3 = false ;
11289 long temp4 ;
11290 int res4 = SWIG_TMPOBJ ;
11291 long temp5 ;
11292 int res5 = SWIG_TMPOBJ ;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char * kwnames[] = {
11297 (char *) "self",(char *) "dc",(char *) "lines", NULL
11298 };
11299
11300 arg4 = &temp4;
11301 arg5 = &temp5;
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11304 if (!SWIG_IsOK(res1)) {
11305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11306 }
11307 arg1 = reinterpret_cast< wxGrid * >(argp1);
11308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11309 if (!SWIG_IsOK(res2)) {
11310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11311 }
11312 if (!argp2) {
11313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11314 }
11315 arg2 = reinterpret_cast< wxDC * >(argp2);
11316 {
11317 if (! PySequence_Check(obj2)) {
11318 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11319 SWIG_fail;
11320 }
11321 arg3 = new wxArrayString;
11322 temp3 = true;
11323 int i, len=PySequence_Length(obj2);
11324 for (i=0; i<len; i++) {
11325 PyObject* item = PySequence_GetItem(obj2, i);
11326 wxString* s = wxString_in_helper(item);
11327 if (PyErr_Occurred()) SWIG_fail;
11328 arg3->Add(*s);
11329 delete s;
11330 Py_DECREF(item);
11331 }
11332 }
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11336 wxPyEndAllowThreads(__tstate);
11337 if (PyErr_Occurred()) SWIG_fail;
11338 }
11339 resultobj = SWIG_Py_Void();
11340 if (SWIG_IsTmpObj(res4)) {
11341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11342 } else {
11343 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11345 }
11346 if (SWIG_IsTmpObj(res5)) {
11347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11348 } else {
11349 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11351 }
11352 {
11353 if (temp3) delete arg3;
11354 }
11355 return resultobj;
11356 fail:
11357 {
11358 if (temp3) delete arg3;
11359 }
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *resultobj = 0;
11366 wxGrid *arg1 = (wxGrid *) 0 ;
11367 void *argp1 = 0 ;
11368 int res1 = 0 ;
11369 PyObject *swig_obj[1] ;
11370
11371 if (!args) SWIG_fail;
11372 swig_obj[0] = args;
11373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11374 if (!SWIG_IsOK(res1)) {
11375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11376 }
11377 arg1 = reinterpret_cast< wxGrid * >(argp1);
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 (arg1)->BeginBatch();
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = SWIG_Py_Void();
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *resultobj = 0;
11393 wxGrid *arg1 = (wxGrid *) 0 ;
11394 void *argp1 = 0 ;
11395 int res1 = 0 ;
11396 PyObject *swig_obj[1] ;
11397
11398 if (!args) SWIG_fail;
11399 swig_obj[0] = args;
11400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11401 if (!SWIG_IsOK(res1)) {
11402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11403 }
11404 arg1 = reinterpret_cast< wxGrid * >(argp1);
11405 {
11406 PyThreadState* __tstate = wxPyBeginAllowThreads();
11407 (arg1)->EndBatch();
11408 wxPyEndAllowThreads(__tstate);
11409 if (PyErr_Occurred()) SWIG_fail;
11410 }
11411 resultobj = SWIG_Py_Void();
11412 return resultobj;
11413 fail:
11414 return NULL;
11415 }
11416
11417
11418 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11419 PyObject *resultobj = 0;
11420 wxGrid *arg1 = (wxGrid *) 0 ;
11421 int result;
11422 void *argp1 = 0 ;
11423 int res1 = 0 ;
11424 PyObject *swig_obj[1] ;
11425
11426 if (!args) SWIG_fail;
11427 swig_obj[0] = args;
11428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11429 if (!SWIG_IsOK(res1)) {
11430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11431 }
11432 arg1 = reinterpret_cast< wxGrid * >(argp1);
11433 {
11434 PyThreadState* __tstate = wxPyBeginAllowThreads();
11435 result = (int)(arg1)->GetBatchCount();
11436 wxPyEndAllowThreads(__tstate);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 resultobj = SWIG_From_int(static_cast< int >(result));
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11447 PyObject *resultobj = 0;
11448 wxGrid *arg1 = (wxGrid *) 0 ;
11449 void *argp1 = 0 ;
11450 int res1 = 0 ;
11451 PyObject *swig_obj[1] ;
11452
11453 if (!args) SWIG_fail;
11454 swig_obj[0] = args;
11455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11456 if (!SWIG_IsOK(res1)) {
11457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11458 }
11459 arg1 = reinterpret_cast< wxGrid * >(argp1);
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 (arg1)->ForceRefresh();
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 resultobj = SWIG_Py_Void();
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11474 PyObject *resultobj = 0;
11475 wxGrid *arg1 = (wxGrid *) 0 ;
11476 bool result;
11477 void *argp1 = 0 ;
11478 int res1 = 0 ;
11479 PyObject *swig_obj[1] ;
11480
11481 if (!args) SWIG_fail;
11482 swig_obj[0] = args;
11483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11484 if (!SWIG_IsOK(res1)) {
11485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11486 }
11487 arg1 = reinterpret_cast< wxGrid * >(argp1);
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = (bool)(arg1)->IsEditable();
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 {
11495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11496 }
11497 return resultobj;
11498 fail:
11499 return NULL;
11500 }
11501
11502
11503 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj = 0;
11505 wxGrid *arg1 = (wxGrid *) 0 ;
11506 bool arg2 ;
11507 void *argp1 = 0 ;
11508 int res1 = 0 ;
11509 bool val2 ;
11510 int ecode2 = 0 ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "edit", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11521 }
11522 arg1 = reinterpret_cast< wxGrid * >(argp1);
11523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11524 if (!SWIG_IsOK(ecode2)) {
11525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11526 }
11527 arg2 = static_cast< bool >(val2);
11528 {
11529 PyThreadState* __tstate = wxPyBeginAllowThreads();
11530 (arg1)->EnableEditing(arg2);
11531 wxPyEndAllowThreads(__tstate);
11532 if (PyErr_Occurred()) SWIG_fail;
11533 }
11534 resultobj = SWIG_Py_Void();
11535 return resultobj;
11536 fail:
11537 return NULL;
11538 }
11539
11540
11541 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11542 PyObject *resultobj = 0;
11543 wxGrid *arg1 = (wxGrid *) 0 ;
11544 bool arg2 = (bool) true ;
11545 void *argp1 = 0 ;
11546 int res1 = 0 ;
11547 bool val2 ;
11548 int ecode2 = 0 ;
11549 PyObject * obj0 = 0 ;
11550 PyObject * obj1 = 0 ;
11551 char * kwnames[] = {
11552 (char *) "self",(char *) "enable", NULL
11553 };
11554
11555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11557 if (!SWIG_IsOK(res1)) {
11558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11559 }
11560 arg1 = reinterpret_cast< wxGrid * >(argp1);
11561 if (obj1) {
11562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11563 if (!SWIG_IsOK(ecode2)) {
11564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11565 }
11566 arg2 = static_cast< bool >(val2);
11567 }
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 (arg1)->EnableCellEditControl(arg2);
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 resultobj = SWIG_Py_Void();
11575 return resultobj;
11576 fail:
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11582 PyObject *resultobj = 0;
11583 wxGrid *arg1 = (wxGrid *) 0 ;
11584 void *argp1 = 0 ;
11585 int res1 = 0 ;
11586 PyObject *swig_obj[1] ;
11587
11588 if (!args) SWIG_fail;
11589 swig_obj[0] = args;
11590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11591 if (!SWIG_IsOK(res1)) {
11592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11593 }
11594 arg1 = reinterpret_cast< wxGrid * >(argp1);
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 (arg1)->DisableCellEditControl();
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 resultobj = SWIG_Py_Void();
11602 return resultobj;
11603 fail:
11604 return NULL;
11605 }
11606
11607
11608 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11609 PyObject *resultobj = 0;
11610 wxGrid *arg1 = (wxGrid *) 0 ;
11611 bool result;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 PyObject *swig_obj[1] ;
11615
11616 if (!args) SWIG_fail;
11617 swig_obj[0] = args;
11618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11619 if (!SWIG_IsOK(res1)) {
11620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11621 }
11622 arg1 = reinterpret_cast< wxGrid * >(argp1);
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 {
11630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11631 }
11632 return resultobj;
11633 fail:
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxGrid *arg1 = (wxGrid *) 0 ;
11641 bool result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11651 }
11652 arg1 = reinterpret_cast< wxGrid * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *resultobj = 0;
11670 wxGrid *arg1 = (wxGrid *) 0 ;
11671 bool result;
11672 void *argp1 = 0 ;
11673 int res1 = 0 ;
11674 PyObject *swig_obj[1] ;
11675
11676 if (!args) SWIG_fail;
11677 swig_obj[0] = args;
11678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11681 }
11682 arg1 = reinterpret_cast< wxGrid * >(argp1);
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 {
11690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11691 }
11692 return resultobj;
11693 fail:
11694 return NULL;
11695 }
11696
11697
11698 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699 PyObject *resultobj = 0;
11700 wxGrid *arg1 = (wxGrid *) 0 ;
11701 bool result;
11702 void *argp1 = 0 ;
11703 int res1 = 0 ;
11704 PyObject *swig_obj[1] ;
11705
11706 if (!args) SWIG_fail;
11707 swig_obj[0] = args;
11708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11711 }
11712 arg1 = reinterpret_cast< wxGrid * >(argp1);
11713 {
11714 PyThreadState* __tstate = wxPyBeginAllowThreads();
11715 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11729 PyObject *resultobj = 0;
11730 wxGrid *arg1 = (wxGrid *) 0 ;
11731 void *argp1 = 0 ;
11732 int res1 = 0 ;
11733 PyObject *swig_obj[1] ;
11734
11735 if (!args) SWIG_fail;
11736 swig_obj[0] = args;
11737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11738 if (!SWIG_IsOK(res1)) {
11739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11740 }
11741 arg1 = reinterpret_cast< wxGrid * >(argp1);
11742 {
11743 PyThreadState* __tstate = wxPyBeginAllowThreads();
11744 (arg1)->ShowCellEditControl();
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 resultobj = SWIG_Py_Void();
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11756 PyObject *resultobj = 0;
11757 wxGrid *arg1 = (wxGrid *) 0 ;
11758 void *argp1 = 0 ;
11759 int res1 = 0 ;
11760 PyObject *swig_obj[1] ;
11761
11762 if (!args) SWIG_fail;
11763 swig_obj[0] = args;
11764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11767 }
11768 arg1 = reinterpret_cast< wxGrid * >(argp1);
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 (arg1)->HideCellEditControl();
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 resultobj = SWIG_Py_Void();
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11783 PyObject *resultobj = 0;
11784 wxGrid *arg1 = (wxGrid *) 0 ;
11785 void *argp1 = 0 ;
11786 int res1 = 0 ;
11787 PyObject *swig_obj[1] ;
11788
11789 if (!args) SWIG_fail;
11790 swig_obj[0] = args;
11791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11792 if (!SWIG_IsOK(res1)) {
11793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11794 }
11795 arg1 = reinterpret_cast< wxGrid * >(argp1);
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 (arg1)->SaveEditControlValue();
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 resultobj = SWIG_Py_Void();
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj = 0;
11811 wxGrid *arg1 = (wxGrid *) 0 ;
11812 int arg2 ;
11813 int arg3 ;
11814 wxGridCellCoords result;
11815 void *argp1 = 0 ;
11816 int res1 = 0 ;
11817 int val2 ;
11818 int ecode2 = 0 ;
11819 int val3 ;
11820 int ecode3 = 0 ;
11821 PyObject * obj0 = 0 ;
11822 PyObject * obj1 = 0 ;
11823 PyObject * obj2 = 0 ;
11824 char * kwnames[] = {
11825 (char *) "self",(char *) "x",(char *) "y", NULL
11826 };
11827
11828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11832 }
11833 arg1 = reinterpret_cast< wxGrid * >(argp1);
11834 ecode2 = SWIG_AsVal_int(obj1, &val2);
11835 if (!SWIG_IsOK(ecode2)) {
11836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11837 }
11838 arg2 = static_cast< int >(val2);
11839 ecode3 = SWIG_AsVal_int(obj2, &val3);
11840 if (!SWIG_IsOK(ecode3)) {
11841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11842 }
11843 arg3 = static_cast< int >(val3);
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = wxGrid_XYToCell(arg1,arg2,arg3);
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj = 0;
11859 wxGrid *arg1 = (wxGrid *) 0 ;
11860 int arg2 ;
11861 int result;
11862 void *argp1 = 0 ;
11863 int res1 = 0 ;
11864 int val2 ;
11865 int ecode2 = 0 ;
11866 PyObject * obj0 = 0 ;
11867 PyObject * obj1 = 0 ;
11868 char * kwnames[] = {
11869 (char *) "self",(char *) "y", NULL
11870 };
11871
11872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11876 }
11877 arg1 = reinterpret_cast< wxGrid * >(argp1);
11878 ecode2 = SWIG_AsVal_int(obj1, &val2);
11879 if (!SWIG_IsOK(ecode2)) {
11880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11881 }
11882 arg2 = static_cast< int >(val2);
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 result = (int)(arg1)->YToRow(arg2);
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 resultobj = SWIG_From_int(static_cast< int >(result));
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj = 0;
11898 wxGrid *arg1 = (wxGrid *) 0 ;
11899 int arg2 ;
11900 int result;
11901 void *argp1 = 0 ;
11902 int res1 = 0 ;
11903 int val2 ;
11904 int ecode2 = 0 ;
11905 PyObject * obj0 = 0 ;
11906 PyObject * obj1 = 0 ;
11907 char * kwnames[] = {
11908 (char *) "self",(char *) "x", NULL
11909 };
11910
11911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) SWIG_fail;
11912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11913 if (!SWIG_IsOK(res1)) {
11914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11915 }
11916 arg1 = reinterpret_cast< wxGrid * >(argp1);
11917 ecode2 = SWIG_AsVal_int(obj1, &val2);
11918 if (!SWIG_IsOK(ecode2)) {
11919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11920 }
11921 arg2 = static_cast< int >(val2);
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 result = (int)(arg1)->XToCol(arg2);
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 resultobj = SWIG_From_int(static_cast< int >(result));
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxGrid *arg1 = (wxGrid *) 0 ;
11938 int arg2 ;
11939 int result;
11940 void *argp1 = 0 ;
11941 int res1 = 0 ;
11942 int val2 ;
11943 int ecode2 = 0 ;
11944 PyObject * obj0 = 0 ;
11945 PyObject * obj1 = 0 ;
11946 char * kwnames[] = {
11947 (char *) "self",(char *) "y", NULL
11948 };
11949
11950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11954 }
11955 arg1 = reinterpret_cast< wxGrid * >(argp1);
11956 ecode2 = SWIG_AsVal_int(obj1, &val2);
11957 if (!SWIG_IsOK(ecode2)) {
11958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11959 }
11960 arg2 = static_cast< int >(val2);
11961 {
11962 PyThreadState* __tstate = wxPyBeginAllowThreads();
11963 result = (int)(arg1)->YToEdgeOfRow(arg2);
11964 wxPyEndAllowThreads(__tstate);
11965 if (PyErr_Occurred()) SWIG_fail;
11966 }
11967 resultobj = SWIG_From_int(static_cast< int >(result));
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = 0;
11976 wxGrid *arg1 = (wxGrid *) 0 ;
11977 int arg2 ;
11978 int result;
11979 void *argp1 = 0 ;
11980 int res1 = 0 ;
11981 int val2 ;
11982 int ecode2 = 0 ;
11983 PyObject * obj0 = 0 ;
11984 PyObject * obj1 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "self",(char *) "x", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11993 }
11994 arg1 = reinterpret_cast< wxGrid * >(argp1);
11995 ecode2 = SWIG_AsVal_int(obj1, &val2);
11996 if (!SWIG_IsOK(ecode2)) {
11997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
11998 }
11999 arg2 = static_cast< int >(val2);
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (int)(arg1)->XToEdgeOfCol(arg2);
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 resultobj = SWIG_From_int(static_cast< int >(result));
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12014 PyObject *resultobj = 0;
12015 wxGrid *arg1 = (wxGrid *) 0 ;
12016 int arg2 ;
12017 int arg3 ;
12018 wxRect result;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 int val2 ;
12022 int ecode2 = 0 ;
12023 int val3 ;
12024 int ecode3 = 0 ;
12025 PyObject * obj0 = 0 ;
12026 PyObject * obj1 = 0 ;
12027 PyObject * obj2 = 0 ;
12028 char * kwnames[] = {
12029 (char *) "self",(char *) "row",(char *) "col", NULL
12030 };
12031
12032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12036 }
12037 arg1 = reinterpret_cast< wxGrid * >(argp1);
12038 ecode2 = SWIG_AsVal_int(obj1, &val2);
12039 if (!SWIG_IsOK(ecode2)) {
12040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12041 }
12042 arg2 = static_cast< int >(val2);
12043 ecode3 = SWIG_AsVal_int(obj2, &val3);
12044 if (!SWIG_IsOK(ecode3)) {
12045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12046 }
12047 arg3 = static_cast< int >(val3);
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 result = (arg1)->CellToRect(arg2,arg3);
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12062 PyObject *resultobj = 0;
12063 wxGrid *arg1 = (wxGrid *) 0 ;
12064 int result;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 PyObject *swig_obj[1] ;
12068
12069 if (!args) SWIG_fail;
12070 swig_obj[0] = args;
12071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12074 }
12075 arg1 = reinterpret_cast< wxGrid * >(argp1);
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (int)(arg1)->GetGridCursorRow();
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_From_int(static_cast< int >(result));
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *resultobj = 0;
12091 wxGrid *arg1 = (wxGrid *) 0 ;
12092 int result;
12093 void *argp1 = 0 ;
12094 int res1 = 0 ;
12095 PyObject *swig_obj[1] ;
12096
12097 if (!args) SWIG_fail;
12098 swig_obj[0] = args;
12099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12100 if (!SWIG_IsOK(res1)) {
12101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12102 }
12103 arg1 = reinterpret_cast< wxGrid * >(argp1);
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 result = (int)(arg1)->GetGridCursorCol();
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 resultobj = SWIG_From_int(static_cast< int >(result));
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12118 PyObject *resultobj = 0;
12119 wxGrid *arg1 = (wxGrid *) 0 ;
12120 int arg2 ;
12121 int arg3 ;
12122 bool arg4 = (bool) true ;
12123 bool result;
12124 void *argp1 = 0 ;
12125 int res1 = 0 ;
12126 int val2 ;
12127 int ecode2 = 0 ;
12128 int val3 ;
12129 int ecode3 = 0 ;
12130 bool val4 ;
12131 int ecode4 = 0 ;
12132 PyObject * obj0 = 0 ;
12133 PyObject * obj1 = 0 ;
12134 PyObject * obj2 = 0 ;
12135 PyObject * obj3 = 0 ;
12136 char * kwnames[] = {
12137 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12138 };
12139
12140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12142 if (!SWIG_IsOK(res1)) {
12143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12144 }
12145 arg1 = reinterpret_cast< wxGrid * >(argp1);
12146 ecode2 = SWIG_AsVal_int(obj1, &val2);
12147 if (!SWIG_IsOK(ecode2)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12149 }
12150 arg2 = static_cast< int >(val2);
12151 ecode3 = SWIG_AsVal_int(obj2, &val3);
12152 if (!SWIG_IsOK(ecode3)) {
12153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12154 }
12155 arg3 = static_cast< int >(val3);
12156 if (obj3) {
12157 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12158 if (!SWIG_IsOK(ecode4)) {
12159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12160 }
12161 arg4 = static_cast< bool >(val4);
12162 }
12163 {
12164 PyThreadState* __tstate = wxPyBeginAllowThreads();
12165 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12166 wxPyEndAllowThreads(__tstate);
12167 if (PyErr_Occurred()) SWIG_fail;
12168 }
12169 {
12170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12171 }
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxGrid *arg1 = (wxGrid *) 0 ;
12181 int arg2 ;
12182 int arg3 ;
12183 void *argp1 = 0 ;
12184 int res1 = 0 ;
12185 int val2 ;
12186 int ecode2 = 0 ;
12187 int val3 ;
12188 int ecode3 = 0 ;
12189 PyObject * obj0 = 0 ;
12190 PyObject * obj1 = 0 ;
12191 PyObject * obj2 = 0 ;
12192 char * kwnames[] = {
12193 (char *) "self",(char *) "row",(char *) "col", NULL
12194 };
12195
12196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12198 if (!SWIG_IsOK(res1)) {
12199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12200 }
12201 arg1 = reinterpret_cast< wxGrid * >(argp1);
12202 ecode2 = SWIG_AsVal_int(obj1, &val2);
12203 if (!SWIG_IsOK(ecode2)) {
12204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12205 }
12206 arg2 = static_cast< int >(val2);
12207 ecode3 = SWIG_AsVal_int(obj2, &val3);
12208 if (!SWIG_IsOK(ecode3)) {
12209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12210 }
12211 arg3 = static_cast< int >(val3);
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 (arg1)->MakeCellVisible(arg2,arg3);
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 resultobj = SWIG_Py_Void();
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj = 0;
12227 wxGrid *arg1 = (wxGrid *) 0 ;
12228 int arg2 ;
12229 int arg3 ;
12230 void *argp1 = 0 ;
12231 int res1 = 0 ;
12232 int val2 ;
12233 int ecode2 = 0 ;
12234 int val3 ;
12235 int ecode3 = 0 ;
12236 PyObject * obj0 = 0 ;
12237 PyObject * obj1 = 0 ;
12238 PyObject * obj2 = 0 ;
12239 char * kwnames[] = {
12240 (char *) "self",(char *) "row",(char *) "col", NULL
12241 };
12242
12243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12245 if (!SWIG_IsOK(res1)) {
12246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12247 }
12248 arg1 = reinterpret_cast< wxGrid * >(argp1);
12249 ecode2 = SWIG_AsVal_int(obj1, &val2);
12250 if (!SWIG_IsOK(ecode2)) {
12251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12252 }
12253 arg2 = static_cast< int >(val2);
12254 ecode3 = SWIG_AsVal_int(obj2, &val3);
12255 if (!SWIG_IsOK(ecode3)) {
12256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12257 }
12258 arg3 = static_cast< int >(val3);
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 (arg1)->SetGridCursor(arg2,arg3);
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 resultobj = SWIG_Py_Void();
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj = 0;
12274 wxGrid *arg1 = (wxGrid *) 0 ;
12275 bool arg2 ;
12276 bool result;
12277 void *argp1 = 0 ;
12278 int res1 = 0 ;
12279 bool val2 ;
12280 int ecode2 = 0 ;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 char * kwnames[] = {
12284 (char *) "self",(char *) "expandSelection", NULL
12285 };
12286
12287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12289 if (!SWIG_IsOK(res1)) {
12290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12291 }
12292 arg1 = reinterpret_cast< wxGrid * >(argp1);
12293 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12294 if (!SWIG_IsOK(ecode2)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12296 }
12297 arg2 = static_cast< bool >(val2);
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 result = (bool)(arg1)->MoveCursorUp(arg2);
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 {
12305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12306 }
12307 return resultobj;
12308 fail:
12309 return NULL;
12310 }
12311
12312
12313 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj = 0;
12315 wxGrid *arg1 = (wxGrid *) 0 ;
12316 bool arg2 ;
12317 bool result;
12318 void *argp1 = 0 ;
12319 int res1 = 0 ;
12320 bool val2 ;
12321 int ecode2 = 0 ;
12322 PyObject * obj0 = 0 ;
12323 PyObject * obj1 = 0 ;
12324 char * kwnames[] = {
12325 (char *) "self",(char *) "expandSelection", NULL
12326 };
12327
12328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12332 }
12333 arg1 = reinterpret_cast< wxGrid * >(argp1);
12334 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12335 if (!SWIG_IsOK(ecode2)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12337 }
12338 arg2 = static_cast< bool >(val2);
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 result = (bool)(arg1)->MoveCursorDown(arg2);
12342 wxPyEndAllowThreads(__tstate);
12343 if (PyErr_Occurred()) SWIG_fail;
12344 }
12345 {
12346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12347 }
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12355 PyObject *resultobj = 0;
12356 wxGrid *arg1 = (wxGrid *) 0 ;
12357 bool arg2 ;
12358 bool result;
12359 void *argp1 = 0 ;
12360 int res1 = 0 ;
12361 bool val2 ;
12362 int ecode2 = 0 ;
12363 PyObject * obj0 = 0 ;
12364 PyObject * obj1 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "expandSelection", NULL
12367 };
12368
12369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12371 if (!SWIG_IsOK(res1)) {
12372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12373 }
12374 arg1 = reinterpret_cast< wxGrid * >(argp1);
12375 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12376 if (!SWIG_IsOK(ecode2)) {
12377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12378 }
12379 arg2 = static_cast< bool >(val2);
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 result = (bool)(arg1)->MoveCursorLeft(arg2);
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj = 0;
12397 wxGrid *arg1 = (wxGrid *) 0 ;
12398 bool arg2 ;
12399 bool result;
12400 void *argp1 = 0 ;
12401 int res1 = 0 ;
12402 bool val2 ;
12403 int ecode2 = 0 ;
12404 PyObject * obj0 = 0 ;
12405 PyObject * obj1 = 0 ;
12406 char * kwnames[] = {
12407 (char *) "self",(char *) "expandSelection", NULL
12408 };
12409
12410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12412 if (!SWIG_IsOK(res1)) {
12413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12414 }
12415 arg1 = reinterpret_cast< wxGrid * >(argp1);
12416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12417 if (!SWIG_IsOK(ecode2)) {
12418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12419 }
12420 arg2 = static_cast< bool >(val2);
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 result = (bool)(arg1)->MoveCursorRight(arg2);
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 {
12428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12429 }
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *resultobj = 0;
12438 wxGrid *arg1 = (wxGrid *) 0 ;
12439 bool result;
12440 void *argp1 = 0 ;
12441 int res1 = 0 ;
12442 PyObject *swig_obj[1] ;
12443
12444 if (!args) SWIG_fail;
12445 swig_obj[0] = args;
12446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12447 if (!SWIG_IsOK(res1)) {
12448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12449 }
12450 arg1 = reinterpret_cast< wxGrid * >(argp1);
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 result = (bool)(arg1)->MovePageDown();
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12459 }
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12467 PyObject *resultobj = 0;
12468 wxGrid *arg1 = (wxGrid *) 0 ;
12469 bool result;
12470 void *argp1 = 0 ;
12471 int res1 = 0 ;
12472 PyObject *swig_obj[1] ;
12473
12474 if (!args) SWIG_fail;
12475 swig_obj[0] = args;
12476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12477 if (!SWIG_IsOK(res1)) {
12478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12479 }
12480 arg1 = reinterpret_cast< wxGrid * >(argp1);
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (bool)(arg1)->MovePageUp();
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12489 }
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12497 PyObject *resultobj = 0;
12498 wxGrid *arg1 = (wxGrid *) 0 ;
12499 bool arg2 ;
12500 bool result;
12501 void *argp1 = 0 ;
12502 int res1 = 0 ;
12503 bool val2 ;
12504 int ecode2 = 0 ;
12505 PyObject * obj0 = 0 ;
12506 PyObject * obj1 = 0 ;
12507 char * kwnames[] = {
12508 (char *) "self",(char *) "expandSelection", NULL
12509 };
12510
12511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12515 }
12516 arg1 = reinterpret_cast< wxGrid * >(argp1);
12517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12518 if (!SWIG_IsOK(ecode2)) {
12519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12520 }
12521 arg2 = static_cast< bool >(val2);
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 {
12529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12530 }
12531 return resultobj;
12532 fail:
12533 return NULL;
12534 }
12535
12536
12537 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj = 0;
12539 wxGrid *arg1 = (wxGrid *) 0 ;
12540 bool arg2 ;
12541 bool result;
12542 void *argp1 = 0 ;
12543 int res1 = 0 ;
12544 bool val2 ;
12545 int ecode2 = 0 ;
12546 PyObject * obj0 = 0 ;
12547 PyObject * obj1 = 0 ;
12548 char * kwnames[] = {
12549 (char *) "self",(char *) "expandSelection", NULL
12550 };
12551
12552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12556 }
12557 arg1 = reinterpret_cast< wxGrid * >(argp1);
12558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12559 if (!SWIG_IsOK(ecode2)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12561 }
12562 arg2 = static_cast< bool >(val2);
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12566 wxPyEndAllowThreads(__tstate);
12567 if (PyErr_Occurred()) SWIG_fail;
12568 }
12569 {
12570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12571 }
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12579 PyObject *resultobj = 0;
12580 wxGrid *arg1 = (wxGrid *) 0 ;
12581 bool arg2 ;
12582 bool result;
12583 void *argp1 = 0 ;
12584 int res1 = 0 ;
12585 bool val2 ;
12586 int ecode2 = 0 ;
12587 PyObject * obj0 = 0 ;
12588 PyObject * obj1 = 0 ;
12589 char * kwnames[] = {
12590 (char *) "self",(char *) "expandSelection", NULL
12591 };
12592
12593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12595 if (!SWIG_IsOK(res1)) {
12596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12597 }
12598 arg1 = reinterpret_cast< wxGrid * >(argp1);
12599 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12600 if (!SWIG_IsOK(ecode2)) {
12601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12602 }
12603 arg2 = static_cast< bool >(val2);
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 {
12611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12612 }
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj = 0;
12621 wxGrid *arg1 = (wxGrid *) 0 ;
12622 bool arg2 ;
12623 bool result;
12624 void *argp1 = 0 ;
12625 int res1 = 0 ;
12626 bool val2 ;
12627 int ecode2 = 0 ;
12628 PyObject * obj0 = 0 ;
12629 PyObject * obj1 = 0 ;
12630 char * kwnames[] = {
12631 (char *) "self",(char *) "expandSelection", NULL
12632 };
12633
12634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12636 if (!SWIG_IsOK(res1)) {
12637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12638 }
12639 arg1 = reinterpret_cast< wxGrid * >(argp1);
12640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12641 if (!SWIG_IsOK(ecode2)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12643 }
12644 arg2 = static_cast< bool >(val2);
12645 {
12646 PyThreadState* __tstate = wxPyBeginAllowThreads();
12647 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12653 }
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxGrid *arg1 = (wxGrid *) 0 ;
12663 int result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 if (!args) SWIG_fail;
12669 swig_obj[0] = args;
12670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12671 if (!SWIG_IsOK(res1)) {
12672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12673 }
12674 arg1 = reinterpret_cast< wxGrid * >(argp1);
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (int)(arg1)->GetDefaultRowLabelSize();
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_From_int(static_cast< int >(result));
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxGrid *arg1 = (wxGrid *) 0 ;
12691 int result;
12692 void *argp1 = 0 ;
12693 int res1 = 0 ;
12694 PyObject *swig_obj[1] ;
12695
12696 if (!args) SWIG_fail;
12697 swig_obj[0] = args;
12698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12699 if (!SWIG_IsOK(res1)) {
12700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12701 }
12702 arg1 = reinterpret_cast< wxGrid * >(argp1);
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = (int)(arg1)->GetRowLabelSize();
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 resultobj = SWIG_From_int(static_cast< int >(result));
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717 PyObject *resultobj = 0;
12718 wxGrid *arg1 = (wxGrid *) 0 ;
12719 int result;
12720 void *argp1 = 0 ;
12721 int res1 = 0 ;
12722 PyObject *swig_obj[1] ;
12723
12724 if (!args) SWIG_fail;
12725 swig_obj[0] = args;
12726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12727 if (!SWIG_IsOK(res1)) {
12728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12729 }
12730 arg1 = reinterpret_cast< wxGrid * >(argp1);
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 result = (int)(arg1)->GetDefaultColLabelSize();
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 resultobj = SWIG_From_int(static_cast< int >(result));
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12745 PyObject *resultobj = 0;
12746 wxGrid *arg1 = (wxGrid *) 0 ;
12747 int result;
12748 void *argp1 = 0 ;
12749 int res1 = 0 ;
12750 PyObject *swig_obj[1] ;
12751
12752 if (!args) SWIG_fail;
12753 swig_obj[0] = args;
12754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12755 if (!SWIG_IsOK(res1)) {
12756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12757 }
12758 arg1 = reinterpret_cast< wxGrid * >(argp1);
12759 {
12760 PyThreadState* __tstate = wxPyBeginAllowThreads();
12761 result = (int)(arg1)->GetColLabelSize();
12762 wxPyEndAllowThreads(__tstate);
12763 if (PyErr_Occurred()) SWIG_fail;
12764 }
12765 resultobj = SWIG_From_int(static_cast< int >(result));
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxGrid *arg1 = (wxGrid *) 0 ;
12775 wxColour result;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 PyObject *swig_obj[1] ;
12779
12780 if (!args) SWIG_fail;
12781 swig_obj[0] = args;
12782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12785 }
12786 arg1 = reinterpret_cast< wxGrid * >(argp1);
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = (arg1)->GetLabelBackgroundColour();
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801 PyObject *resultobj = 0;
12802 wxGrid *arg1 = (wxGrid *) 0 ;
12803 wxColour result;
12804 void *argp1 = 0 ;
12805 int res1 = 0 ;
12806 PyObject *swig_obj[1] ;
12807
12808 if (!args) SWIG_fail;
12809 swig_obj[0] = args;
12810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12811 if (!SWIG_IsOK(res1)) {
12812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12813 }
12814 arg1 = reinterpret_cast< wxGrid * >(argp1);
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (arg1)->GetLabelTextColour();
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *resultobj = 0;
12830 wxGrid *arg1 = (wxGrid *) 0 ;
12831 wxFont result;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12841 }
12842 arg1 = reinterpret_cast< wxGrid * >(argp1);
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (arg1)->GetLabelFont();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12850 return resultobj;
12851 fail:
12852 return NULL;
12853 }
12854
12855
12856 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12857 PyObject *resultobj = 0;
12858 wxGrid *arg1 = (wxGrid *) 0 ;
12859 int *arg2 = (int *) 0 ;
12860 int *arg3 = (int *) 0 ;
12861 void *argp1 = 0 ;
12862 int res1 = 0 ;
12863 int temp2 ;
12864 int res2 = SWIG_TMPOBJ ;
12865 int temp3 ;
12866 int res3 = SWIG_TMPOBJ ;
12867 PyObject *swig_obj[1] ;
12868
12869 arg2 = &temp2;
12870 arg3 = &temp3;
12871 if (!args) SWIG_fail;
12872 swig_obj[0] = args;
12873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12874 if (!SWIG_IsOK(res1)) {
12875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12876 }
12877 arg1 = reinterpret_cast< wxGrid * >(argp1);
12878 {
12879 PyThreadState* __tstate = wxPyBeginAllowThreads();
12880 (arg1)->GetRowLabelAlignment(arg2,arg3);
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 resultobj = SWIG_Py_Void();
12885 if (SWIG_IsTmpObj(res2)) {
12886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12887 } else {
12888 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12890 }
12891 if (SWIG_IsTmpObj(res3)) {
12892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12893 } else {
12894 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12896 }
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 PyObject *resultobj = 0;
12905 wxGrid *arg1 = (wxGrid *) 0 ;
12906 int *arg2 = (int *) 0 ;
12907 int *arg3 = (int *) 0 ;
12908 void *argp1 = 0 ;
12909 int res1 = 0 ;
12910 int temp2 ;
12911 int res2 = SWIG_TMPOBJ ;
12912 int temp3 ;
12913 int res3 = SWIG_TMPOBJ ;
12914 PyObject *swig_obj[1] ;
12915
12916 arg2 = &temp2;
12917 arg3 = &temp3;
12918 if (!args) SWIG_fail;
12919 swig_obj[0] = args;
12920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12921 if (!SWIG_IsOK(res1)) {
12922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12923 }
12924 arg1 = reinterpret_cast< wxGrid * >(argp1);
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 (arg1)->GetColLabelAlignment(arg2,arg3);
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_Py_Void();
12932 if (SWIG_IsTmpObj(res2)) {
12933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12934 } else {
12935 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12937 }
12938 if (SWIG_IsTmpObj(res3)) {
12939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12940 } else {
12941 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12943 }
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12951 PyObject *resultobj = 0;
12952 wxGrid *arg1 = (wxGrid *) 0 ;
12953 int result;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 PyObject *swig_obj[1] ;
12957
12958 if (!args) SWIG_fail;
12959 swig_obj[0] = args;
12960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12963 }
12964 arg1 = reinterpret_cast< wxGrid * >(argp1);
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (int)(arg1)->GetColLabelTextOrientation();
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 resultobj = SWIG_From_int(static_cast< int >(result));
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj = 0;
12980 wxGrid *arg1 = (wxGrid *) 0 ;
12981 int arg2 ;
12982 wxString result;
12983 void *argp1 = 0 ;
12984 int res1 = 0 ;
12985 int val2 ;
12986 int ecode2 = 0 ;
12987 PyObject * obj0 = 0 ;
12988 PyObject * obj1 = 0 ;
12989 char * kwnames[] = {
12990 (char *) "self",(char *) "row", NULL
12991 };
12992
12993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
12994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12995 if (!SWIG_IsOK(res1)) {
12996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12997 }
12998 arg1 = reinterpret_cast< wxGrid * >(argp1);
12999 ecode2 = SWIG_AsVal_int(obj1, &val2);
13000 if (!SWIG_IsOK(ecode2)) {
13001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13002 }
13003 arg2 = static_cast< int >(val2);
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (arg1)->GetRowLabelValue(arg2);
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 {
13011 #if wxUSE_UNICODE
13012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13013 #else
13014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13015 #endif
13016 }
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj = 0;
13025 wxGrid *arg1 = (wxGrid *) 0 ;
13026 int arg2 ;
13027 wxString result;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 int val2 ;
13031 int ecode2 = 0 ;
13032 PyObject * obj0 = 0 ;
13033 PyObject * obj1 = 0 ;
13034 char * kwnames[] = {
13035 (char *) "self",(char *) "col", NULL
13036 };
13037
13038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13042 }
13043 arg1 = reinterpret_cast< wxGrid * >(argp1);
13044 ecode2 = SWIG_AsVal_int(obj1, &val2);
13045 if (!SWIG_IsOK(ecode2)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13047 }
13048 arg2 = static_cast< int >(val2);
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (arg1)->GetColLabelValue(arg2);
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 {
13056 #if wxUSE_UNICODE
13057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13058 #else
13059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13060 #endif
13061 }
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *resultobj = 0;
13070 wxGrid *arg1 = (wxGrid *) 0 ;
13071 wxColour result;
13072 void *argp1 = 0 ;
13073 int res1 = 0 ;
13074 PyObject *swig_obj[1] ;
13075
13076 if (!args) SWIG_fail;
13077 swig_obj[0] = args;
13078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13079 if (!SWIG_IsOK(res1)) {
13080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13081 }
13082 arg1 = reinterpret_cast< wxGrid * >(argp1);
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (arg1)->GetGridLineColour();
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13097 PyObject *resultobj = 0;
13098 wxGrid *arg1 = (wxGrid *) 0 ;
13099 wxColour result;
13100 void *argp1 = 0 ;
13101 int res1 = 0 ;
13102 PyObject *swig_obj[1] ;
13103
13104 if (!args) SWIG_fail;
13105 swig_obj[0] = args;
13106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13107 if (!SWIG_IsOK(res1)) {
13108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13109 }
13110 arg1 = reinterpret_cast< wxGrid * >(argp1);
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (arg1)->GetCellHighlightColour();
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13118 return resultobj;
13119 fail:
13120 return NULL;
13121 }
13122
13123
13124 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13125 PyObject *resultobj = 0;
13126 wxGrid *arg1 = (wxGrid *) 0 ;
13127 int result;
13128 void *argp1 = 0 ;
13129 int res1 = 0 ;
13130 PyObject *swig_obj[1] ;
13131
13132 if (!args) SWIG_fail;
13133 swig_obj[0] = args;
13134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13135 if (!SWIG_IsOK(res1)) {
13136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13137 }
13138 arg1 = reinterpret_cast< wxGrid * >(argp1);
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 result = (int)(arg1)->GetCellHighlightPenWidth();
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 resultobj = SWIG_From_int(static_cast< int >(result));
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13153 PyObject *resultobj = 0;
13154 wxGrid *arg1 = (wxGrid *) 0 ;
13155 int result;
13156 void *argp1 = 0 ;
13157 int res1 = 0 ;
13158 PyObject *swig_obj[1] ;
13159
13160 if (!args) SWIG_fail;
13161 swig_obj[0] = args;
13162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13163 if (!SWIG_IsOK(res1)) {
13164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13165 }
13166 arg1 = reinterpret_cast< wxGrid * >(argp1);
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 result = (int)(arg1)->GetCellHighlightROPenWidth();
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 resultobj = SWIG_From_int(static_cast< int >(result));
13174 return resultobj;
13175 fail:
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxGrid *arg1 = (wxGrid *) 0 ;
13183 int arg2 ;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 int val2 ;
13187 int ecode2 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "self",(char *) "width", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13198 }
13199 arg1 = reinterpret_cast< wxGrid * >(argp1);
13200 ecode2 = SWIG_AsVal_int(obj1, &val2);
13201 if (!SWIG_IsOK(ecode2)) {
13202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13203 }
13204 arg2 = static_cast< int >(val2);
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 (arg1)->SetRowLabelSize(arg2);
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 resultobj = SWIG_Py_Void();
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxGrid *arg1 = (wxGrid *) 0 ;
13221 int arg2 ;
13222 void *argp1 = 0 ;
13223 int res1 = 0 ;
13224 int val2 ;
13225 int ecode2 = 0 ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 char * kwnames[] = {
13229 (char *) "self",(char *) "height", NULL
13230 };
13231
13232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13234 if (!SWIG_IsOK(res1)) {
13235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13236 }
13237 arg1 = reinterpret_cast< wxGrid * >(argp1);
13238 ecode2 = SWIG_AsVal_int(obj1, &val2);
13239 if (!SWIG_IsOK(ecode2)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13241 }
13242 arg2 = static_cast< int >(val2);
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 (arg1)->SetColLabelSize(arg2);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 resultobj = SWIG_Py_Void();
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 wxGrid *arg1 = (wxGrid *) 0 ;
13259 wxColour *arg2 = 0 ;
13260 void *argp1 = 0 ;
13261 int res1 = 0 ;
13262 wxColour temp2 ;
13263 PyObject * obj0 = 0 ;
13264 PyObject * obj1 = 0 ;
13265 char * kwnames[] = {
13266 (char *) "self",(char *)"arg2", NULL
13267 };
13268
13269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13273 }
13274 arg1 = reinterpret_cast< wxGrid * >(argp1);
13275 {
13276 arg2 = &temp2;
13277 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 resultobj = SWIG_Py_Void();
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 wxGrid *arg1 = (wxGrid *) 0 ;
13295 wxColour *arg2 = 0 ;
13296 void *argp1 = 0 ;
13297 int res1 = 0 ;
13298 wxColour temp2 ;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 char * kwnames[] = {
13302 (char *) "self",(char *)"arg2", NULL
13303 };
13304
13305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13307 if (!SWIG_IsOK(res1)) {
13308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13309 }
13310 arg1 = reinterpret_cast< wxGrid * >(argp1);
13311 {
13312 arg2 = &temp2;
13313 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = SWIG_Py_Void();
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = 0;
13330 wxGrid *arg1 = (wxGrid *) 0 ;
13331 wxFont *arg2 = 0 ;
13332 void *argp1 = 0 ;
13333 int res1 = 0 ;
13334 void *argp2 = 0 ;
13335 int res2 = 0 ;
13336 PyObject * obj0 = 0 ;
13337 PyObject * obj1 = 0 ;
13338 char * kwnames[] = {
13339 (char *) "self",(char *)"arg2", NULL
13340 };
13341
13342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13344 if (!SWIG_IsOK(res1)) {
13345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13346 }
13347 arg1 = reinterpret_cast< wxGrid * >(argp1);
13348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13349 if (!SWIG_IsOK(res2)) {
13350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13351 }
13352 if (!argp2) {
13353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13354 }
13355 arg2 = reinterpret_cast< wxFont * >(argp2);
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 (arg1)->SetLabelFont((wxFont const &)*arg2);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_Py_Void();
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = 0;
13371 wxGrid *arg1 = (wxGrid *) 0 ;
13372 int arg2 ;
13373 int arg3 ;
13374 void *argp1 = 0 ;
13375 int res1 = 0 ;
13376 int val2 ;
13377 int ecode2 = 0 ;
13378 int val3 ;
13379 int ecode3 = 0 ;
13380 PyObject * obj0 = 0 ;
13381 PyObject * obj1 = 0 ;
13382 PyObject * obj2 = 0 ;
13383 char * kwnames[] = {
13384 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13385 };
13386
13387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13389 if (!SWIG_IsOK(res1)) {
13390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13391 }
13392 arg1 = reinterpret_cast< wxGrid * >(argp1);
13393 ecode2 = SWIG_AsVal_int(obj1, &val2);
13394 if (!SWIG_IsOK(ecode2)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13396 }
13397 arg2 = static_cast< int >(val2);
13398 ecode3 = SWIG_AsVal_int(obj2, &val3);
13399 if (!SWIG_IsOK(ecode3)) {
13400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13401 }
13402 arg3 = static_cast< int >(val3);
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 (arg1)->SetRowLabelAlignment(arg2,arg3);
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_Py_Void();
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj = 0;
13418 wxGrid *arg1 = (wxGrid *) 0 ;
13419 int arg2 ;
13420 int arg3 ;
13421 void *argp1 = 0 ;
13422 int res1 = 0 ;
13423 int val2 ;
13424 int ecode2 = 0 ;
13425 int val3 ;
13426 int ecode3 = 0 ;
13427 PyObject * obj0 = 0 ;
13428 PyObject * obj1 = 0 ;
13429 PyObject * obj2 = 0 ;
13430 char * kwnames[] = {
13431 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13432 };
13433
13434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13436 if (!SWIG_IsOK(res1)) {
13437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13438 }
13439 arg1 = reinterpret_cast< wxGrid * >(argp1);
13440 ecode2 = SWIG_AsVal_int(obj1, &val2);
13441 if (!SWIG_IsOK(ecode2)) {
13442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13443 }
13444 arg2 = static_cast< int >(val2);
13445 ecode3 = SWIG_AsVal_int(obj2, &val3);
13446 if (!SWIG_IsOK(ecode3)) {
13447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13448 }
13449 arg3 = static_cast< int >(val3);
13450 {
13451 PyThreadState* __tstate = wxPyBeginAllowThreads();
13452 (arg1)->SetColLabelAlignment(arg2,arg3);
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 resultobj = SWIG_Py_Void();
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13464 PyObject *resultobj = 0;
13465 wxGrid *arg1 = (wxGrid *) 0 ;
13466 int arg2 ;
13467 void *argp1 = 0 ;
13468 int res1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 PyObject * obj0 = 0 ;
13472 PyObject * obj1 = 0 ;
13473 char * kwnames[] = {
13474 (char *) "self",(char *) "textOrientation", NULL
13475 };
13476
13477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13481 }
13482 arg1 = reinterpret_cast< wxGrid * >(argp1);
13483 ecode2 = SWIG_AsVal_int(obj1, &val2);
13484 if (!SWIG_IsOK(ecode2)) {
13485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13486 }
13487 arg2 = static_cast< int >(val2);
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 (arg1)->SetColLabelTextOrientation(arg2);
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_Py_Void();
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13502 PyObject *resultobj = 0;
13503 wxGrid *arg1 = (wxGrid *) 0 ;
13504 int arg2 ;
13505 wxString *arg3 = 0 ;
13506 void *argp1 = 0 ;
13507 int res1 = 0 ;
13508 int val2 ;
13509 int ecode2 = 0 ;
13510 bool temp3 = false ;
13511 PyObject * obj0 = 0 ;
13512 PyObject * obj1 = 0 ;
13513 PyObject * obj2 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "self",(char *) "row",(char *)"arg3", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) 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_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13522 }
13523 arg1 = reinterpret_cast< wxGrid * >(argp1);
13524 ecode2 = SWIG_AsVal_int(obj1, &val2);
13525 if (!SWIG_IsOK(ecode2)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13527 }
13528 arg2 = static_cast< int >(val2);
13529 {
13530 arg3 = wxString_in_helper(obj2);
13531 if (arg3 == NULL) SWIG_fail;
13532 temp3 = true;
13533 }
13534 {
13535 PyThreadState* __tstate = wxPyBeginAllowThreads();
13536 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 resultobj = SWIG_Py_Void();
13541 {
13542 if (temp3)
13543 delete arg3;
13544 }
13545 return resultobj;
13546 fail:
13547 {
13548 if (temp3)
13549 delete arg3;
13550 }
13551 return NULL;
13552 }
13553
13554
13555 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13556 PyObject *resultobj = 0;
13557 wxGrid *arg1 = (wxGrid *) 0 ;
13558 int arg2 ;
13559 wxString *arg3 = 0 ;
13560 void *argp1 = 0 ;
13561 int res1 = 0 ;
13562 int val2 ;
13563 int ecode2 = 0 ;
13564 bool temp3 = false ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 PyObject * obj2 = 0 ;
13568 char * kwnames[] = {
13569 (char *) "self",(char *) "col",(char *)"arg3", NULL
13570 };
13571
13572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13574 if (!SWIG_IsOK(res1)) {
13575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13576 }
13577 arg1 = reinterpret_cast< wxGrid * >(argp1);
13578 ecode2 = SWIG_AsVal_int(obj1, &val2);
13579 if (!SWIG_IsOK(ecode2)) {
13580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13581 }
13582 arg2 = static_cast< int >(val2);
13583 {
13584 arg3 = wxString_in_helper(obj2);
13585 if (arg3 == NULL) SWIG_fail;
13586 temp3 = true;
13587 }
13588 {
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 resultobj = SWIG_Py_Void();
13595 {
13596 if (temp3)
13597 delete arg3;
13598 }
13599 return resultobj;
13600 fail:
13601 {
13602 if (temp3)
13603 delete arg3;
13604 }
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj = 0;
13611 wxGrid *arg1 = (wxGrid *) 0 ;
13612 wxColour *arg2 = 0 ;
13613 void *argp1 = 0 ;
13614 int res1 = 0 ;
13615 wxColour temp2 ;
13616 PyObject * obj0 = 0 ;
13617 PyObject * obj1 = 0 ;
13618 char * kwnames[] = {
13619 (char *) "self",(char *)"arg2", NULL
13620 };
13621
13622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13624 if (!SWIG_IsOK(res1)) {
13625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13626 }
13627 arg1 = reinterpret_cast< wxGrid * >(argp1);
13628 {
13629 arg2 = &temp2;
13630 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13631 }
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_Py_Void();
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = 0;
13647 wxGrid *arg1 = (wxGrid *) 0 ;
13648 wxColour *arg2 = 0 ;
13649 void *argp1 = 0 ;
13650 int res1 = 0 ;
13651 wxColour temp2 ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "self",(char *)"arg2", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13662 }
13663 arg1 = reinterpret_cast< wxGrid * >(argp1);
13664 {
13665 arg2 = &temp2;
13666 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13667 }
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_Py_Void();
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 wxGrid *arg1 = (wxGrid *) 0 ;
13684 int arg2 ;
13685 void *argp1 = 0 ;
13686 int res1 = 0 ;
13687 int val2 ;
13688 int ecode2 = 0 ;
13689 PyObject * obj0 = 0 ;
13690 PyObject * obj1 = 0 ;
13691 char * kwnames[] = {
13692 (char *) "self",(char *) "width", NULL
13693 };
13694
13695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13697 if (!SWIG_IsOK(res1)) {
13698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13699 }
13700 arg1 = reinterpret_cast< wxGrid * >(argp1);
13701 ecode2 = SWIG_AsVal_int(obj1, &val2);
13702 if (!SWIG_IsOK(ecode2)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13704 }
13705 arg2 = static_cast< int >(val2);
13706 {
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 (arg1)->SetCellHighlightPenWidth(arg2);
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 resultobj = SWIG_Py_Void();
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj = 0;
13721 wxGrid *arg1 = (wxGrid *) 0 ;
13722 int arg2 ;
13723 void *argp1 = 0 ;
13724 int res1 = 0 ;
13725 int val2 ;
13726 int ecode2 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 char * kwnames[] = {
13730 (char *) "self",(char *) "width", NULL
13731 };
13732
13733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13735 if (!SWIG_IsOK(res1)) {
13736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13737 }
13738 arg1 = reinterpret_cast< wxGrid * >(argp1);
13739 ecode2 = SWIG_AsVal_int(obj1, &val2);
13740 if (!SWIG_IsOK(ecode2)) {
13741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13742 }
13743 arg2 = static_cast< int >(val2);
13744 {
13745 PyThreadState* __tstate = wxPyBeginAllowThreads();
13746 (arg1)->SetCellHighlightROPenWidth(arg2);
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 resultobj = SWIG_Py_Void();
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = 0;
13759 wxGrid *arg1 = (wxGrid *) 0 ;
13760 bool arg2 = (bool) true ;
13761 void *argp1 = 0 ;
13762 int res1 = 0 ;
13763 bool val2 ;
13764 int ecode2 = 0 ;
13765 PyObject * obj0 = 0 ;
13766 PyObject * obj1 = 0 ;
13767 char * kwnames[] = {
13768 (char *) "self",(char *) "enable", NULL
13769 };
13770
13771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13773 if (!SWIG_IsOK(res1)) {
13774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13775 }
13776 arg1 = reinterpret_cast< wxGrid * >(argp1);
13777 if (obj1) {
13778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13779 if (!SWIG_IsOK(ecode2)) {
13780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13781 }
13782 arg2 = static_cast< bool >(val2);
13783 }
13784 {
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 (arg1)->EnableDragRowSize(arg2);
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_Py_Void();
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13798 PyObject *resultobj = 0;
13799 wxGrid *arg1 = (wxGrid *) 0 ;
13800 void *argp1 = 0 ;
13801 int res1 = 0 ;
13802 PyObject *swig_obj[1] ;
13803
13804 if (!args) SWIG_fail;
13805 swig_obj[0] = args;
13806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13807 if (!SWIG_IsOK(res1)) {
13808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13809 }
13810 arg1 = reinterpret_cast< wxGrid * >(argp1);
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 (arg1)->DisableDragRowSize();
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_Py_Void();
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13825 PyObject *resultobj = 0;
13826 wxGrid *arg1 = (wxGrid *) 0 ;
13827 bool result;
13828 void *argp1 = 0 ;
13829 int res1 = 0 ;
13830 PyObject *swig_obj[1] ;
13831
13832 if (!args) SWIG_fail;
13833 swig_obj[0] = args;
13834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13837 }
13838 arg1 = reinterpret_cast< wxGrid * >(argp1);
13839 {
13840 PyThreadState* __tstate = wxPyBeginAllowThreads();
13841 result = (bool)(arg1)->CanDragRowSize();
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 {
13846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13847 }
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13855 PyObject *resultobj = 0;
13856 wxGrid *arg1 = (wxGrid *) 0 ;
13857 bool arg2 = (bool) true ;
13858 void *argp1 = 0 ;
13859 int res1 = 0 ;
13860 bool val2 ;
13861 int ecode2 = 0 ;
13862 PyObject * obj0 = 0 ;
13863 PyObject * obj1 = 0 ;
13864 char * kwnames[] = {
13865 (char *) "self",(char *) "enable", NULL
13866 };
13867
13868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13870 if (!SWIG_IsOK(res1)) {
13871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13872 }
13873 arg1 = reinterpret_cast< wxGrid * >(argp1);
13874 if (obj1) {
13875 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13876 if (!SWIG_IsOK(ecode2)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13878 }
13879 arg2 = static_cast< bool >(val2);
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 (arg1)->EnableDragColSize(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_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13895 PyObject *resultobj = 0;
13896 wxGrid *arg1 = (wxGrid *) 0 ;
13897 void *argp1 = 0 ;
13898 int res1 = 0 ;
13899 PyObject *swig_obj[1] ;
13900
13901 if (!args) SWIG_fail;
13902 swig_obj[0] = args;
13903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13904 if (!SWIG_IsOK(res1)) {
13905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13906 }
13907 arg1 = reinterpret_cast< wxGrid * >(argp1);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 (arg1)->DisableDragColSize();
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_Py_Void();
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13922 PyObject *resultobj = 0;
13923 wxGrid *arg1 = (wxGrid *) 0 ;
13924 bool result;
13925 void *argp1 = 0 ;
13926 int res1 = 0 ;
13927 PyObject *swig_obj[1] ;
13928
13929 if (!args) SWIG_fail;
13930 swig_obj[0] = args;
13931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13932 if (!SWIG_IsOK(res1)) {
13933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13934 }
13935 arg1 = reinterpret_cast< wxGrid * >(argp1);
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 result = (bool)(arg1)->CanDragColSize();
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 {
13943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13944 }
13945 return resultobj;
13946 fail:
13947 return NULL;
13948 }
13949
13950
13951 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj = 0;
13953 wxGrid *arg1 = (wxGrid *) 0 ;
13954 bool arg2 = (bool) true ;
13955 void *argp1 = 0 ;
13956 int res1 = 0 ;
13957 bool val2 ;
13958 int ecode2 = 0 ;
13959 PyObject * obj0 = 0 ;
13960 PyObject * obj1 = 0 ;
13961 char * kwnames[] = {
13962 (char *) "self",(char *) "enable", NULL
13963 };
13964
13965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
13966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13967 if (!SWIG_IsOK(res1)) {
13968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13969 }
13970 arg1 = reinterpret_cast< wxGrid * >(argp1);
13971 if (obj1) {
13972 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13973 if (!SWIG_IsOK(ecode2)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
13975 }
13976 arg2 = static_cast< bool >(val2);
13977 }
13978 {
13979 PyThreadState* __tstate = wxPyBeginAllowThreads();
13980 (arg1)->EnableDragGridSize(arg2);
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_Py_Void();
13985 return resultobj;
13986 fail:
13987 return NULL;
13988 }
13989
13990
13991 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13992 PyObject *resultobj = 0;
13993 wxGrid *arg1 = (wxGrid *) 0 ;
13994 void *argp1 = 0 ;
13995 int res1 = 0 ;
13996 PyObject *swig_obj[1] ;
13997
13998 if (!args) SWIG_fail;
13999 swig_obj[0] = args;
14000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14001 if (!SWIG_IsOK(res1)) {
14002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14003 }
14004 arg1 = reinterpret_cast< wxGrid * >(argp1);
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 (arg1)->DisableDragGridSize();
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 return resultobj;
14013 fail:
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14019 PyObject *resultobj = 0;
14020 wxGrid *arg1 = (wxGrid *) 0 ;
14021 bool result;
14022 void *argp1 = 0 ;
14023 int res1 = 0 ;
14024 PyObject *swig_obj[1] ;
14025
14026 if (!args) SWIG_fail;
14027 swig_obj[0] = args;
14028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14029 if (!SWIG_IsOK(res1)) {
14030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14031 }
14032 arg1 = reinterpret_cast< wxGrid * >(argp1);
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (bool)(arg1)->CanDragGridSize();
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 {
14040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14041 }
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj = 0;
14050 wxGrid *arg1 = (wxGrid *) 0 ;
14051 bool arg2 = (bool) true ;
14052 void *argp1 = 0 ;
14053 int res1 = 0 ;
14054 bool val2 ;
14055 int ecode2 = 0 ;
14056 PyObject * obj0 = 0 ;
14057 PyObject * obj1 = 0 ;
14058 char * kwnames[] = {
14059 (char *) "self",(char *) "enable", NULL
14060 };
14061
14062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14064 if (!SWIG_IsOK(res1)) {
14065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14066 }
14067 arg1 = reinterpret_cast< wxGrid * >(argp1);
14068 if (obj1) {
14069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14070 if (!SWIG_IsOK(ecode2)) {
14071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14072 }
14073 arg2 = static_cast< bool >(val2);
14074 }
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 (arg1)->EnableDragCell(arg2);
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 resultobj = SWIG_Py_Void();
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14089 PyObject *resultobj = 0;
14090 wxGrid *arg1 = (wxGrid *) 0 ;
14091 void *argp1 = 0 ;
14092 int res1 = 0 ;
14093 PyObject *swig_obj[1] ;
14094
14095 if (!args) SWIG_fail;
14096 swig_obj[0] = args;
14097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14098 if (!SWIG_IsOK(res1)) {
14099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14100 }
14101 arg1 = reinterpret_cast< wxGrid * >(argp1);
14102 {
14103 PyThreadState* __tstate = wxPyBeginAllowThreads();
14104 (arg1)->DisableDragCell();
14105 wxPyEndAllowThreads(__tstate);
14106 if (PyErr_Occurred()) SWIG_fail;
14107 }
14108 resultobj = SWIG_Py_Void();
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116 PyObject *resultobj = 0;
14117 wxGrid *arg1 = (wxGrid *) 0 ;
14118 bool result;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 PyObject *swig_obj[1] ;
14122
14123 if (!args) SWIG_fail;
14124 swig_obj[0] = args;
14125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14126 if (!SWIG_IsOK(res1)) {
14127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14128 }
14129 arg1 = reinterpret_cast< wxGrid * >(argp1);
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 result = (bool)(arg1)->CanDragCell();
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 {
14137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14138 }
14139 return resultobj;
14140 fail:
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxGrid *arg1 = (wxGrid *) 0 ;
14148 int arg2 ;
14149 int arg3 ;
14150 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 int val2 ;
14154 int ecode2 = 0 ;
14155 int val3 ;
14156 int ecode3 = 0 ;
14157 void *argp4 = 0 ;
14158 int res4 = 0 ;
14159 PyObject * obj0 = 0 ;
14160 PyObject * obj1 = 0 ;
14161 PyObject * obj2 = 0 ;
14162 PyObject * obj3 = 0 ;
14163 char * kwnames[] = {
14164 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14165 };
14166
14167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14171 }
14172 arg1 = reinterpret_cast< wxGrid * >(argp1);
14173 ecode2 = SWIG_AsVal_int(obj1, &val2);
14174 if (!SWIG_IsOK(ecode2)) {
14175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14176 }
14177 arg2 = static_cast< int >(val2);
14178 ecode3 = SWIG_AsVal_int(obj2, &val3);
14179 if (!SWIG_IsOK(ecode3)) {
14180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14181 }
14182 arg3 = static_cast< int >(val3);
14183 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14184 if (!SWIG_IsOK(res4)) {
14185 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14186 }
14187 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 (arg1)->SetAttr(arg2,arg3,arg4);
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 resultobj = SWIG_Py_Void();
14195 return resultobj;
14196 fail:
14197 return NULL;
14198 }
14199
14200
14201 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14202 PyObject *resultobj = 0;
14203 wxGrid *arg1 = (wxGrid *) 0 ;
14204 int arg2 ;
14205 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14206 void *argp1 = 0 ;
14207 int res1 = 0 ;
14208 int val2 ;
14209 int ecode2 = 0 ;
14210 void *argp3 = 0 ;
14211 int res3 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 PyObject * obj2 = 0 ;
14215 char * kwnames[] = {
14216 (char *) "self",(char *) "row",(char *) "attr", NULL
14217 };
14218
14219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14223 }
14224 arg1 = reinterpret_cast< wxGrid * >(argp1);
14225 ecode2 = SWIG_AsVal_int(obj1, &val2);
14226 if (!SWIG_IsOK(ecode2)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14228 }
14229 arg2 = static_cast< int >(val2);
14230 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14231 if (!SWIG_IsOK(res3)) {
14232 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14233 }
14234 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14235 {
14236 PyThreadState* __tstate = wxPyBeginAllowThreads();
14237 (arg1)->SetRowAttr(arg2,arg3);
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 resultobj = SWIG_Py_Void();
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj = 0;
14250 wxGrid *arg1 = (wxGrid *) 0 ;
14251 int arg2 ;
14252 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14253 void *argp1 = 0 ;
14254 int res1 = 0 ;
14255 int val2 ;
14256 int ecode2 = 0 ;
14257 void *argp3 = 0 ;
14258 int res3 = 0 ;
14259 PyObject * obj0 = 0 ;
14260 PyObject * obj1 = 0 ;
14261 PyObject * obj2 = 0 ;
14262 char * kwnames[] = {
14263 (char *) "self",(char *) "col",(char *) "attr", NULL
14264 };
14265
14266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14270 }
14271 arg1 = reinterpret_cast< wxGrid * >(argp1);
14272 ecode2 = SWIG_AsVal_int(obj1, &val2);
14273 if (!SWIG_IsOK(ecode2)) {
14274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14275 }
14276 arg2 = static_cast< int >(val2);
14277 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14278 if (!SWIG_IsOK(res3)) {
14279 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14280 }
14281 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 (arg1)->SetColAttr(arg2,arg3);
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_Py_Void();
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj = 0;
14297 wxGrid *arg1 = (wxGrid *) 0 ;
14298 int arg2 ;
14299 int arg3 ;
14300 wxGridCellAttr *result = 0 ;
14301 void *argp1 = 0 ;
14302 int res1 = 0 ;
14303 int val2 ;
14304 int ecode2 = 0 ;
14305 int val3 ;
14306 int ecode3 = 0 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 PyObject * obj2 = 0 ;
14310 char * kwnames[] = {
14311 (char *) "self",(char *) "row",(char *) "col", NULL
14312 };
14313
14314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14316 if (!SWIG_IsOK(res1)) {
14317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14318 }
14319 arg1 = reinterpret_cast< wxGrid * >(argp1);
14320 ecode2 = SWIG_AsVal_int(obj1, &val2);
14321 if (!SWIG_IsOK(ecode2)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14323 }
14324 arg2 = static_cast< int >(val2);
14325 ecode3 = SWIG_AsVal_int(obj2, &val3);
14326 if (!SWIG_IsOK(ecode3)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14328 }
14329 arg3 = static_cast< int >(val3);
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 {
14337 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14338 }
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxGrid *arg1 = (wxGrid *) 0 ;
14348 int arg2 ;
14349 void *argp1 = 0 ;
14350 int res1 = 0 ;
14351 int val2 ;
14352 int ecode2 = 0 ;
14353 PyObject * obj0 = 0 ;
14354 PyObject * obj1 = 0 ;
14355 char * kwnames[] = {
14356 (char *) "self",(char *) "col", NULL
14357 };
14358
14359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14363 }
14364 arg1 = reinterpret_cast< wxGrid * >(argp1);
14365 ecode2 = SWIG_AsVal_int(obj1, &val2);
14366 if (!SWIG_IsOK(ecode2)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14368 }
14369 arg2 = static_cast< int >(val2);
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 (arg1)->SetColFormatBool(arg2);
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 resultobj = SWIG_Py_Void();
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = 0;
14385 wxGrid *arg1 = (wxGrid *) 0 ;
14386 int arg2 ;
14387 void *argp1 = 0 ;
14388 int res1 = 0 ;
14389 int val2 ;
14390 int ecode2 = 0 ;
14391 PyObject * obj0 = 0 ;
14392 PyObject * obj1 = 0 ;
14393 char * kwnames[] = {
14394 (char *) "self",(char *) "col", NULL
14395 };
14396
14397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14401 }
14402 arg1 = reinterpret_cast< wxGrid * >(argp1);
14403 ecode2 = SWIG_AsVal_int(obj1, &val2);
14404 if (!SWIG_IsOK(ecode2)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14406 }
14407 arg2 = static_cast< int >(val2);
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 (arg1)->SetColFormatNumber(arg2);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_Py_Void();
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj = 0;
14423 wxGrid *arg1 = (wxGrid *) 0 ;
14424 int arg2 ;
14425 int arg3 = (int) -1 ;
14426 int arg4 = (int) -1 ;
14427 void *argp1 = 0 ;
14428 int res1 = 0 ;
14429 int val2 ;
14430 int ecode2 = 0 ;
14431 int val3 ;
14432 int ecode3 = 0 ;
14433 int val4 ;
14434 int ecode4 = 0 ;
14435 PyObject * obj0 = 0 ;
14436 PyObject * obj1 = 0 ;
14437 PyObject * obj2 = 0 ;
14438 PyObject * obj3 = 0 ;
14439 char * kwnames[] = {
14440 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14441 };
14442
14443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14445 if (!SWIG_IsOK(res1)) {
14446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14447 }
14448 arg1 = reinterpret_cast< wxGrid * >(argp1);
14449 ecode2 = SWIG_AsVal_int(obj1, &val2);
14450 if (!SWIG_IsOK(ecode2)) {
14451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14452 }
14453 arg2 = static_cast< int >(val2);
14454 if (obj2) {
14455 ecode3 = SWIG_AsVal_int(obj2, &val3);
14456 if (!SWIG_IsOK(ecode3)) {
14457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14458 }
14459 arg3 = static_cast< int >(val3);
14460 }
14461 if (obj3) {
14462 ecode4 = SWIG_AsVal_int(obj3, &val4);
14463 if (!SWIG_IsOK(ecode4)) {
14464 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14465 }
14466 arg4 = static_cast< int >(val4);
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_Py_Void();
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14482 PyObject *resultobj = 0;
14483 wxGrid *arg1 = (wxGrid *) 0 ;
14484 int arg2 ;
14485 wxString *arg3 = 0 ;
14486 void *argp1 = 0 ;
14487 int res1 = 0 ;
14488 int val2 ;
14489 int ecode2 = 0 ;
14490 bool temp3 = false ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 char * kwnames[] = {
14495 (char *) "self",(char *) "col",(char *) "typeName", NULL
14496 };
14497
14498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14500 if (!SWIG_IsOK(res1)) {
14501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14502 }
14503 arg1 = reinterpret_cast< wxGrid * >(argp1);
14504 ecode2 = SWIG_AsVal_int(obj1, &val2);
14505 if (!SWIG_IsOK(ecode2)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14507 }
14508 arg2 = static_cast< int >(val2);
14509 {
14510 arg3 = wxString_in_helper(obj2);
14511 if (arg3 == NULL) SWIG_fail;
14512 temp3 = true;
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = SWIG_Py_Void();
14521 {
14522 if (temp3)
14523 delete arg3;
14524 }
14525 return resultobj;
14526 fail:
14527 {
14528 if (temp3)
14529 delete arg3;
14530 }
14531 return NULL;
14532 }
14533
14534
14535 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj = 0;
14537 wxGrid *arg1 = (wxGrid *) 0 ;
14538 bool arg2 = (bool) true ;
14539 void *argp1 = 0 ;
14540 int res1 = 0 ;
14541 bool val2 ;
14542 int ecode2 = 0 ;
14543 PyObject * obj0 = 0 ;
14544 PyObject * obj1 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "enable", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14553 }
14554 arg1 = reinterpret_cast< wxGrid * >(argp1);
14555 if (obj1) {
14556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14557 if (!SWIG_IsOK(ecode2)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14559 }
14560 arg2 = static_cast< bool >(val2);
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->EnableGridLines(arg2);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576 PyObject *resultobj = 0;
14577 wxGrid *arg1 = (wxGrid *) 0 ;
14578 bool result;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 PyObject *swig_obj[1] ;
14582
14583 if (!args) SWIG_fail;
14584 swig_obj[0] = args;
14585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14588 }
14589 arg1 = reinterpret_cast< wxGrid * >(argp1);
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (bool)(arg1)->GridLinesEnabled();
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 {
14597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14598 }
14599 return resultobj;
14600 fail:
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14606 PyObject *resultobj = 0;
14607 wxGrid *arg1 = (wxGrid *) 0 ;
14608 int result;
14609 void *argp1 = 0 ;
14610 int res1 = 0 ;
14611 PyObject *swig_obj[1] ;
14612
14613 if (!args) SWIG_fail;
14614 swig_obj[0] = args;
14615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14616 if (!SWIG_IsOK(res1)) {
14617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14618 }
14619 arg1 = reinterpret_cast< wxGrid * >(argp1);
14620 {
14621 PyThreadState* __tstate = wxPyBeginAllowThreads();
14622 result = (int)(arg1)->GetDefaultRowSize();
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 resultobj = SWIG_From_int(static_cast< int >(result));
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 wxGrid *arg1 = (wxGrid *) 0 ;
14636 int arg2 ;
14637 int result;
14638 void *argp1 = 0 ;
14639 int res1 = 0 ;
14640 int val2 ;
14641 int ecode2 = 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 char * kwnames[] = {
14645 (char *) "self",(char *) "row", NULL
14646 };
14647
14648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14652 }
14653 arg1 = reinterpret_cast< wxGrid * >(argp1);
14654 ecode2 = SWIG_AsVal_int(obj1, &val2);
14655 if (!SWIG_IsOK(ecode2)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14657 }
14658 arg2 = static_cast< int >(val2);
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (int)(arg1)->GetRowSize(arg2);
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 resultobj = SWIG_From_int(static_cast< int >(result));
14666 return resultobj;
14667 fail:
14668 return NULL;
14669 }
14670
14671
14672 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14673 PyObject *resultobj = 0;
14674 wxGrid *arg1 = (wxGrid *) 0 ;
14675 int result;
14676 void *argp1 = 0 ;
14677 int res1 = 0 ;
14678 PyObject *swig_obj[1] ;
14679
14680 if (!args) SWIG_fail;
14681 swig_obj[0] = args;
14682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14683 if (!SWIG_IsOK(res1)) {
14684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14685 }
14686 arg1 = reinterpret_cast< wxGrid * >(argp1);
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 result = (int)(arg1)->GetDefaultColSize();
14690 wxPyEndAllowThreads(__tstate);
14691 if (PyErr_Occurred()) SWIG_fail;
14692 }
14693 resultobj = SWIG_From_int(static_cast< int >(result));
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj = 0;
14702 wxGrid *arg1 = (wxGrid *) 0 ;
14703 int arg2 ;
14704 int result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 int val2 ;
14708 int ecode2 = 0 ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 char * kwnames[] = {
14712 (char *) "self",(char *) "col", NULL
14713 };
14714
14715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14717 if (!SWIG_IsOK(res1)) {
14718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14719 }
14720 arg1 = reinterpret_cast< wxGrid * >(argp1);
14721 ecode2 = SWIG_AsVal_int(obj1, &val2);
14722 if (!SWIG_IsOK(ecode2)) {
14723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14724 }
14725 arg2 = static_cast< int >(val2);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (int)(arg1)->GetColSize(arg2);
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 resultobj = SWIG_From_int(static_cast< int >(result));
14733 return resultobj;
14734 fail:
14735 return NULL;
14736 }
14737
14738
14739 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14740 PyObject *resultobj = 0;
14741 wxGrid *arg1 = (wxGrid *) 0 ;
14742 wxColour result;
14743 void *argp1 = 0 ;
14744 int res1 = 0 ;
14745 PyObject *swig_obj[1] ;
14746
14747 if (!args) SWIG_fail;
14748 swig_obj[0] = args;
14749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14750 if (!SWIG_IsOK(res1)) {
14751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14752 }
14753 arg1 = reinterpret_cast< wxGrid * >(argp1);
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 result = (arg1)->GetDefaultCellBackgroundColour();
14757 wxPyEndAllowThreads(__tstate);
14758 if (PyErr_Occurred()) SWIG_fail;
14759 }
14760 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14761 return resultobj;
14762 fail:
14763 return NULL;
14764 }
14765
14766
14767 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14768 PyObject *resultobj = 0;
14769 wxGrid *arg1 = (wxGrid *) 0 ;
14770 int arg2 ;
14771 int arg3 ;
14772 wxColour result;
14773 void *argp1 = 0 ;
14774 int res1 = 0 ;
14775 int val2 ;
14776 int ecode2 = 0 ;
14777 int val3 ;
14778 int ecode3 = 0 ;
14779 PyObject * obj0 = 0 ;
14780 PyObject * obj1 = 0 ;
14781 PyObject * obj2 = 0 ;
14782 char * kwnames[] = {
14783 (char *) "self",(char *) "row",(char *) "col", NULL
14784 };
14785
14786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14788 if (!SWIG_IsOK(res1)) {
14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14790 }
14791 arg1 = reinterpret_cast< wxGrid * >(argp1);
14792 ecode2 = SWIG_AsVal_int(obj1, &val2);
14793 if (!SWIG_IsOK(ecode2)) {
14794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14795 }
14796 arg2 = static_cast< int >(val2);
14797 ecode3 = SWIG_AsVal_int(obj2, &val3);
14798 if (!SWIG_IsOK(ecode3)) {
14799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14800 }
14801 arg3 = static_cast< int >(val3);
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14805 wxPyEndAllowThreads(__tstate);
14806 if (PyErr_Occurred()) SWIG_fail;
14807 }
14808 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14809 return resultobj;
14810 fail:
14811 return NULL;
14812 }
14813
14814
14815 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14816 PyObject *resultobj = 0;
14817 wxGrid *arg1 = (wxGrid *) 0 ;
14818 wxColour result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 PyObject *swig_obj[1] ;
14822
14823 if (!args) SWIG_fail;
14824 swig_obj[0] = args;
14825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14826 if (!SWIG_IsOK(res1)) {
14827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14828 }
14829 arg1 = reinterpret_cast< wxGrid * >(argp1);
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 result = (arg1)->GetDefaultCellTextColour();
14833 wxPyEndAllowThreads(__tstate);
14834 if (PyErr_Occurred()) SWIG_fail;
14835 }
14836 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14837 return resultobj;
14838 fail:
14839 return NULL;
14840 }
14841
14842
14843 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14844 PyObject *resultobj = 0;
14845 wxGrid *arg1 = (wxGrid *) 0 ;
14846 int arg2 ;
14847 int arg3 ;
14848 wxColour result;
14849 void *argp1 = 0 ;
14850 int res1 = 0 ;
14851 int val2 ;
14852 int ecode2 = 0 ;
14853 int val3 ;
14854 int ecode3 = 0 ;
14855 PyObject * obj0 = 0 ;
14856 PyObject * obj1 = 0 ;
14857 PyObject * obj2 = 0 ;
14858 char * kwnames[] = {
14859 (char *) "self",(char *) "row",(char *) "col", NULL
14860 };
14861
14862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14864 if (!SWIG_IsOK(res1)) {
14865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14866 }
14867 arg1 = reinterpret_cast< wxGrid * >(argp1);
14868 ecode2 = SWIG_AsVal_int(obj1, &val2);
14869 if (!SWIG_IsOK(ecode2)) {
14870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14871 }
14872 arg2 = static_cast< int >(val2);
14873 ecode3 = SWIG_AsVal_int(obj2, &val3);
14874 if (!SWIG_IsOK(ecode3)) {
14875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14876 }
14877 arg3 = static_cast< int >(val3);
14878 {
14879 PyThreadState* __tstate = wxPyBeginAllowThreads();
14880 result = (arg1)->GetCellTextColour(arg2,arg3);
14881 wxPyEndAllowThreads(__tstate);
14882 if (PyErr_Occurred()) SWIG_fail;
14883 }
14884 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14885 return resultobj;
14886 fail:
14887 return NULL;
14888 }
14889
14890
14891 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14892 PyObject *resultobj = 0;
14893 wxGrid *arg1 = (wxGrid *) 0 ;
14894 wxFont result;
14895 void *argp1 = 0 ;
14896 int res1 = 0 ;
14897 PyObject *swig_obj[1] ;
14898
14899 if (!args) SWIG_fail;
14900 swig_obj[0] = args;
14901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14902 if (!SWIG_IsOK(res1)) {
14903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14904 }
14905 arg1 = reinterpret_cast< wxGrid * >(argp1);
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 result = (arg1)->GetDefaultCellFont();
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14913 return resultobj;
14914 fail:
14915 return NULL;
14916 }
14917
14918
14919 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14920 PyObject *resultobj = 0;
14921 wxGrid *arg1 = (wxGrid *) 0 ;
14922 int arg2 ;
14923 int arg3 ;
14924 wxFont result;
14925 void *argp1 = 0 ;
14926 int res1 = 0 ;
14927 int val2 ;
14928 int ecode2 = 0 ;
14929 int val3 ;
14930 int ecode3 = 0 ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 PyObject * obj2 = 0 ;
14934 char * kwnames[] = {
14935 (char *) "self",(char *) "row",(char *) "col", NULL
14936 };
14937
14938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14942 }
14943 arg1 = reinterpret_cast< wxGrid * >(argp1);
14944 ecode2 = SWIG_AsVal_int(obj1, &val2);
14945 if (!SWIG_IsOK(ecode2)) {
14946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
14947 }
14948 arg2 = static_cast< int >(val2);
14949 ecode3 = SWIG_AsVal_int(obj2, &val3);
14950 if (!SWIG_IsOK(ecode3)) {
14951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
14952 }
14953 arg3 = static_cast< int >(val3);
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (arg1)->GetCellFont(arg2,arg3);
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968 PyObject *resultobj = 0;
14969 wxGrid *arg1 = (wxGrid *) 0 ;
14970 int *arg2 = (int *) 0 ;
14971 int *arg3 = (int *) 0 ;
14972 void *argp1 = 0 ;
14973 int res1 = 0 ;
14974 int temp2 ;
14975 int res2 = SWIG_TMPOBJ ;
14976 int temp3 ;
14977 int res3 = SWIG_TMPOBJ ;
14978 PyObject *swig_obj[1] ;
14979
14980 arg2 = &temp2;
14981 arg3 = &temp3;
14982 if (!args) SWIG_fail;
14983 swig_obj[0] = args;
14984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14985 if (!SWIG_IsOK(res1)) {
14986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
14987 }
14988 arg1 = reinterpret_cast< wxGrid * >(argp1);
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 (arg1)->GetDefaultCellAlignment(arg2,arg3);
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 resultobj = SWIG_Py_Void();
14996 if (SWIG_IsTmpObj(res2)) {
14997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14998 } else {
14999 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15001 }
15002 if (SWIG_IsTmpObj(res3)) {
15003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15004 } else {
15005 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15007 }
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj = 0;
15016 wxGrid *arg1 = (wxGrid *) 0 ;
15017 int arg2 ;
15018 int arg3 ;
15019 int *arg4 = (int *) 0 ;
15020 int *arg5 = (int *) 0 ;
15021 void *argp1 = 0 ;
15022 int res1 = 0 ;
15023 int val2 ;
15024 int ecode2 = 0 ;
15025 int val3 ;
15026 int ecode3 = 0 ;
15027 int temp4 ;
15028 int res4 = SWIG_TMPOBJ ;
15029 int temp5 ;
15030 int res5 = SWIG_TMPOBJ ;
15031 PyObject * obj0 = 0 ;
15032 PyObject * obj1 = 0 ;
15033 PyObject * obj2 = 0 ;
15034 char * kwnames[] = {
15035 (char *) "self",(char *) "row",(char *) "col", NULL
15036 };
15037
15038 arg4 = &temp4;
15039 arg5 = &temp5;
15040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15042 if (!SWIG_IsOK(res1)) {
15043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15044 }
15045 arg1 = reinterpret_cast< wxGrid * >(argp1);
15046 ecode2 = SWIG_AsVal_int(obj1, &val2);
15047 if (!SWIG_IsOK(ecode2)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15049 }
15050 arg2 = static_cast< int >(val2);
15051 ecode3 = SWIG_AsVal_int(obj2, &val3);
15052 if (!SWIG_IsOK(ecode3)) {
15053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15054 }
15055 arg3 = static_cast< int >(val3);
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 resultobj = SWIG_Py_Void();
15063 if (SWIG_IsTmpObj(res4)) {
15064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15065 } else {
15066 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15068 }
15069 if (SWIG_IsTmpObj(res5)) {
15070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15071 } else {
15072 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 PyObject *resultobj = 0;
15083 wxGrid *arg1 = (wxGrid *) 0 ;
15084 bool result;
15085 void *argp1 = 0 ;
15086 int res1 = 0 ;
15087 PyObject *swig_obj[1] ;
15088
15089 if (!args) SWIG_fail;
15090 swig_obj[0] = args;
15091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15092 if (!SWIG_IsOK(res1)) {
15093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15094 }
15095 arg1 = reinterpret_cast< wxGrid * >(argp1);
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 result = (bool)(arg1)->GetDefaultCellOverflow();
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 {
15103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15104 }
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj = 0;
15113 wxGrid *arg1 = (wxGrid *) 0 ;
15114 int arg2 ;
15115 int arg3 ;
15116 bool result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 int val2 ;
15120 int ecode2 = 0 ;
15121 int val3 ;
15122 int ecode3 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 PyObject * obj2 = 0 ;
15126 char * kwnames[] = {
15127 (char *) "self",(char *) "row",(char *) "col", NULL
15128 };
15129
15130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15134 }
15135 arg1 = reinterpret_cast< wxGrid * >(argp1);
15136 ecode2 = SWIG_AsVal_int(obj1, &val2);
15137 if (!SWIG_IsOK(ecode2)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15139 }
15140 arg2 = static_cast< int >(val2);
15141 ecode3 = SWIG_AsVal_int(obj2, &val3);
15142 if (!SWIG_IsOK(ecode3)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15144 }
15145 arg3 = static_cast< int >(val3);
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 {
15153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15154 }
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj = 0;
15163 wxGrid *arg1 = (wxGrid *) 0 ;
15164 int arg2 ;
15165 int arg3 ;
15166 int *arg4 = (int *) 0 ;
15167 int *arg5 = (int *) 0 ;
15168 void *argp1 = 0 ;
15169 int res1 = 0 ;
15170 int val2 ;
15171 int ecode2 = 0 ;
15172 int val3 ;
15173 int ecode3 = 0 ;
15174 int temp4 ;
15175 int res4 = SWIG_TMPOBJ ;
15176 int temp5 ;
15177 int res5 = SWIG_TMPOBJ ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 char * kwnames[] = {
15182 (char *) "self",(char *) "row",(char *) "col", NULL
15183 };
15184
15185 arg4 = &temp4;
15186 arg5 = &temp5;
15187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",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_GetCellSize" "', 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_GetCellSize" "', 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_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15201 }
15202 arg3 = static_cast< int >(val3);
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15206 wxPyEndAllowThreads(__tstate);
15207 if (PyErr_Occurred()) SWIG_fail;
15208 }
15209 resultobj = SWIG_Py_Void();
15210 if (SWIG_IsTmpObj(res4)) {
15211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15212 } else {
15213 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15215 }
15216 if (SWIG_IsTmpObj(res5)) {
15217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15218 } else {
15219 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15221 }
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxGrid *arg1 = (wxGrid *) 0 ;
15231 int arg2 ;
15232 bool arg3 = (bool) false ;
15233 void *argp1 = 0 ;
15234 int res1 = 0 ;
15235 int val2 ;
15236 int ecode2 = 0 ;
15237 bool val3 ;
15238 int ecode3 = 0 ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 PyObject * obj2 = 0 ;
15242 char * kwnames[] = {
15243 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15244 };
15245
15246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15248 if (!SWIG_IsOK(res1)) {
15249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15250 }
15251 arg1 = reinterpret_cast< wxGrid * >(argp1);
15252 ecode2 = SWIG_AsVal_int(obj1, &val2);
15253 if (!SWIG_IsOK(ecode2)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15255 }
15256 arg2 = static_cast< int >(val2);
15257 if (obj2) {
15258 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15259 if (!SWIG_IsOK(ecode3)) {
15260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15261 }
15262 arg3 = static_cast< bool >(val3);
15263 }
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 (arg1)->SetDefaultRowSize(arg2,arg3);
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 resultobj = SWIG_Py_Void();
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj = 0;
15279 wxGrid *arg1 = (wxGrid *) 0 ;
15280 int arg2 ;
15281 int arg3 ;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 int val2 ;
15285 int ecode2 = 0 ;
15286 int val3 ;
15287 int ecode3 = 0 ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 PyObject * obj2 = 0 ;
15291 char * kwnames[] = {
15292 (char *) "self",(char *) "row",(char *) "height", NULL
15293 };
15294
15295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15299 }
15300 arg1 = reinterpret_cast< wxGrid * >(argp1);
15301 ecode2 = SWIG_AsVal_int(obj1, &val2);
15302 if (!SWIG_IsOK(ecode2)) {
15303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15304 }
15305 arg2 = static_cast< int >(val2);
15306 ecode3 = SWIG_AsVal_int(obj2, &val3);
15307 if (!SWIG_IsOK(ecode3)) {
15308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15309 }
15310 arg3 = static_cast< int >(val3);
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 (arg1)->SetRowSize(arg2,arg3);
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 resultobj = SWIG_Py_Void();
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15325 PyObject *resultobj = 0;
15326 wxGrid *arg1 = (wxGrid *) 0 ;
15327 int arg2 ;
15328 bool arg3 = (bool) false ;
15329 void *argp1 = 0 ;
15330 int res1 = 0 ;
15331 int val2 ;
15332 int ecode2 = 0 ;
15333 bool val3 ;
15334 int ecode3 = 0 ;
15335 PyObject * obj0 = 0 ;
15336 PyObject * obj1 = 0 ;
15337 PyObject * obj2 = 0 ;
15338 char * kwnames[] = {
15339 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15340 };
15341
15342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15344 if (!SWIG_IsOK(res1)) {
15345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15346 }
15347 arg1 = reinterpret_cast< wxGrid * >(argp1);
15348 ecode2 = SWIG_AsVal_int(obj1, &val2);
15349 if (!SWIG_IsOK(ecode2)) {
15350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15351 }
15352 arg2 = static_cast< int >(val2);
15353 if (obj2) {
15354 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15355 if (!SWIG_IsOK(ecode3)) {
15356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15357 }
15358 arg3 = static_cast< bool >(val3);
15359 }
15360 {
15361 PyThreadState* __tstate = wxPyBeginAllowThreads();
15362 (arg1)->SetDefaultColSize(arg2,arg3);
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 resultobj = SWIG_Py_Void();
15367 return resultobj;
15368 fail:
15369 return NULL;
15370 }
15371
15372
15373 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15374 PyObject *resultobj = 0;
15375 wxGrid *arg1 = (wxGrid *) 0 ;
15376 int arg2 ;
15377 int arg3 ;
15378 void *argp1 = 0 ;
15379 int res1 = 0 ;
15380 int val2 ;
15381 int ecode2 = 0 ;
15382 int val3 ;
15383 int ecode3 = 0 ;
15384 PyObject * obj0 = 0 ;
15385 PyObject * obj1 = 0 ;
15386 PyObject * obj2 = 0 ;
15387 char * kwnames[] = {
15388 (char *) "self",(char *) "col",(char *) "width", NULL
15389 };
15390
15391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15395 }
15396 arg1 = reinterpret_cast< wxGrid * >(argp1);
15397 ecode2 = SWIG_AsVal_int(obj1, &val2);
15398 if (!SWIG_IsOK(ecode2)) {
15399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15400 }
15401 arg2 = static_cast< int >(val2);
15402 ecode3 = SWIG_AsVal_int(obj2, &val3);
15403 if (!SWIG_IsOK(ecode3)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15405 }
15406 arg3 = static_cast< int >(val3);
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 (arg1)->SetColSize(arg2,arg3);
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_Py_Void();
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15421 PyObject *resultobj = 0;
15422 wxGrid *arg1 = (wxGrid *) 0 ;
15423 int arg2 ;
15424 bool arg3 = (bool) true ;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 int val2 ;
15428 int ecode2 = 0 ;
15429 bool val3 ;
15430 int ecode3 = 0 ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 PyObject * obj2 = 0 ;
15434 char * kwnames[] = {
15435 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15436 };
15437
15438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15440 if (!SWIG_IsOK(res1)) {
15441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15442 }
15443 arg1 = reinterpret_cast< wxGrid * >(argp1);
15444 ecode2 = SWIG_AsVal_int(obj1, &val2);
15445 if (!SWIG_IsOK(ecode2)) {
15446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15447 }
15448 arg2 = static_cast< int >(val2);
15449 if (obj2) {
15450 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15451 if (!SWIG_IsOK(ecode3)) {
15452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15453 }
15454 arg3 = static_cast< bool >(val3);
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 (arg1)->AutoSizeColumn(arg2,arg3);
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 resultobj = SWIG_Py_Void();
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj = 0;
15471 wxGrid *arg1 = (wxGrid *) 0 ;
15472 int arg2 ;
15473 bool arg3 = (bool) true ;
15474 void *argp1 = 0 ;
15475 int res1 = 0 ;
15476 int val2 ;
15477 int ecode2 = 0 ;
15478 bool val3 ;
15479 int ecode3 = 0 ;
15480 PyObject * obj0 = 0 ;
15481 PyObject * obj1 = 0 ;
15482 PyObject * obj2 = 0 ;
15483 char * kwnames[] = {
15484 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15485 };
15486
15487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15491 }
15492 arg1 = reinterpret_cast< wxGrid * >(argp1);
15493 ecode2 = SWIG_AsVal_int(obj1, &val2);
15494 if (!SWIG_IsOK(ecode2)) {
15495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15496 }
15497 arg2 = static_cast< int >(val2);
15498 if (obj2) {
15499 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15500 if (!SWIG_IsOK(ecode3)) {
15501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15502 }
15503 arg3 = static_cast< bool >(val3);
15504 }
15505 {
15506 PyThreadState* __tstate = wxPyBeginAllowThreads();
15507 (arg1)->AutoSizeRow(arg2,arg3);
15508 wxPyEndAllowThreads(__tstate);
15509 if (PyErr_Occurred()) SWIG_fail;
15510 }
15511 resultobj = SWIG_Py_Void();
15512 return resultobj;
15513 fail:
15514 return NULL;
15515 }
15516
15517
15518 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj = 0;
15520 wxGrid *arg1 = (wxGrid *) 0 ;
15521 bool arg2 = (bool) true ;
15522 void *argp1 = 0 ;
15523 int res1 = 0 ;
15524 bool val2 ;
15525 int ecode2 = 0 ;
15526 PyObject * obj0 = 0 ;
15527 PyObject * obj1 = 0 ;
15528 char * kwnames[] = {
15529 (char *) "self",(char *) "setAsMin", NULL
15530 };
15531
15532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15536 }
15537 arg1 = reinterpret_cast< wxGrid * >(argp1);
15538 if (obj1) {
15539 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15540 if (!SWIG_IsOK(ecode2)) {
15541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15542 }
15543 arg2 = static_cast< bool >(val2);
15544 }
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 (arg1)->AutoSizeColumns(arg2);
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 resultobj = SWIG_Py_Void();
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15559 PyObject *resultobj = 0;
15560 wxGrid *arg1 = (wxGrid *) 0 ;
15561 bool arg2 = (bool) true ;
15562 void *argp1 = 0 ;
15563 int res1 = 0 ;
15564 bool val2 ;
15565 int ecode2 = 0 ;
15566 PyObject * obj0 = 0 ;
15567 PyObject * obj1 = 0 ;
15568 char * kwnames[] = {
15569 (char *) "self",(char *) "setAsMin", NULL
15570 };
15571
15572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15574 if (!SWIG_IsOK(res1)) {
15575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15576 }
15577 arg1 = reinterpret_cast< wxGrid * >(argp1);
15578 if (obj1) {
15579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15580 if (!SWIG_IsOK(ecode2)) {
15581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15582 }
15583 arg2 = static_cast< bool >(val2);
15584 }
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 (arg1)->AutoSizeRows(arg2);
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_Py_Void();
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15599 PyObject *resultobj = 0;
15600 wxGrid *arg1 = (wxGrid *) 0 ;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 PyObject *swig_obj[1] ;
15604
15605 if (!args) SWIG_fail;
15606 swig_obj[0] = args;
15607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15610 }
15611 arg1 = reinterpret_cast< wxGrid * >(argp1);
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 (arg1)->AutoSize();
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 resultobj = SWIG_Py_Void();
15619 return resultobj;
15620 fail:
15621 return NULL;
15622 }
15623
15624
15625 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15626 PyObject *resultobj = 0;
15627 wxGrid *arg1 = (wxGrid *) 0 ;
15628 int arg2 ;
15629 void *argp1 = 0 ;
15630 int res1 = 0 ;
15631 int val2 ;
15632 int ecode2 = 0 ;
15633 PyObject * obj0 = 0 ;
15634 PyObject * obj1 = 0 ;
15635 char * kwnames[] = {
15636 (char *) "self",(char *) "row", NULL
15637 };
15638
15639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15641 if (!SWIG_IsOK(res1)) {
15642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15643 }
15644 arg1 = reinterpret_cast< wxGrid * >(argp1);
15645 ecode2 = SWIG_AsVal_int(obj1, &val2);
15646 if (!SWIG_IsOK(ecode2)) {
15647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15648 }
15649 arg2 = static_cast< int >(val2);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 (arg1)->AutoSizeRowLabelSize(arg2);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = SWIG_Py_Void();
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15664 PyObject *resultobj = 0;
15665 wxGrid *arg1 = (wxGrid *) 0 ;
15666 int arg2 ;
15667 void *argp1 = 0 ;
15668 int res1 = 0 ;
15669 int val2 ;
15670 int ecode2 = 0 ;
15671 PyObject * obj0 = 0 ;
15672 PyObject * obj1 = 0 ;
15673 char * kwnames[] = {
15674 (char *) "self",(char *) "col", NULL
15675 };
15676
15677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15679 if (!SWIG_IsOK(res1)) {
15680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15681 }
15682 arg1 = reinterpret_cast< wxGrid * >(argp1);
15683 ecode2 = SWIG_AsVal_int(obj1, &val2);
15684 if (!SWIG_IsOK(ecode2)) {
15685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15686 }
15687 arg2 = static_cast< int >(val2);
15688 {
15689 PyThreadState* __tstate = wxPyBeginAllowThreads();
15690 (arg1)->AutoSizeColLabelSize(arg2);
15691 wxPyEndAllowThreads(__tstate);
15692 if (PyErr_Occurred()) SWIG_fail;
15693 }
15694 resultobj = SWIG_Py_Void();
15695 return resultobj;
15696 fail:
15697 return NULL;
15698 }
15699
15700
15701 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15702 PyObject *resultobj = 0;
15703 wxGrid *arg1 = (wxGrid *) 0 ;
15704 int arg2 ;
15705 int arg3 ;
15706 void *argp1 = 0 ;
15707 int res1 = 0 ;
15708 int val2 ;
15709 int ecode2 = 0 ;
15710 int val3 ;
15711 int ecode3 = 0 ;
15712 PyObject * obj0 = 0 ;
15713 PyObject * obj1 = 0 ;
15714 PyObject * obj2 = 0 ;
15715 char * kwnames[] = {
15716 (char *) "self",(char *) "col",(char *) "width", NULL
15717 };
15718
15719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15723 }
15724 arg1 = reinterpret_cast< wxGrid * >(argp1);
15725 ecode2 = SWIG_AsVal_int(obj1, &val2);
15726 if (!SWIG_IsOK(ecode2)) {
15727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15728 }
15729 arg2 = static_cast< int >(val2);
15730 ecode3 = SWIG_AsVal_int(obj2, &val3);
15731 if (!SWIG_IsOK(ecode3)) {
15732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15733 }
15734 arg3 = static_cast< int >(val3);
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 (arg1)->SetColMinimalWidth(arg2,arg3);
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = SWIG_Py_Void();
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = 0;
15750 wxGrid *arg1 = (wxGrid *) 0 ;
15751 int arg2 ;
15752 int arg3 ;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 int val2 ;
15756 int ecode2 = 0 ;
15757 int val3 ;
15758 int ecode3 = 0 ;
15759 PyObject * obj0 = 0 ;
15760 PyObject * obj1 = 0 ;
15761 PyObject * obj2 = 0 ;
15762 char * kwnames[] = {
15763 (char *) "self",(char *) "row",(char *) "width", NULL
15764 };
15765
15766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15770 }
15771 arg1 = reinterpret_cast< wxGrid * >(argp1);
15772 ecode2 = SWIG_AsVal_int(obj1, &val2);
15773 if (!SWIG_IsOK(ecode2)) {
15774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
15775 }
15776 arg2 = static_cast< int >(val2);
15777 ecode3 = SWIG_AsVal_int(obj2, &val3);
15778 if (!SWIG_IsOK(ecode3)) {
15779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
15780 }
15781 arg3 = static_cast< int >(val3);
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 (arg1)->SetRowMinimalHeight(arg2,arg3);
15785 wxPyEndAllowThreads(__tstate);
15786 if (PyErr_Occurred()) SWIG_fail;
15787 }
15788 resultobj = SWIG_Py_Void();
15789 return resultobj;
15790 fail:
15791 return NULL;
15792 }
15793
15794
15795 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15796 PyObject *resultobj = 0;
15797 wxGrid *arg1 = (wxGrid *) 0 ;
15798 int arg2 ;
15799 void *argp1 = 0 ;
15800 int res1 = 0 ;
15801 int val2 ;
15802 int ecode2 = 0 ;
15803 PyObject * obj0 = 0 ;
15804 PyObject * obj1 = 0 ;
15805 char * kwnames[] = {
15806 (char *) "self",(char *) "width", NULL
15807 };
15808
15809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
15810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15813 }
15814 arg1 = reinterpret_cast< wxGrid * >(argp1);
15815 ecode2 = SWIG_AsVal_int(obj1, &val2);
15816 if (!SWIG_IsOK(ecode2)) {
15817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
15818 }
15819 arg2 = static_cast< int >(val2);
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 (arg1)->SetColMinimalAcceptableWidth(arg2);
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 resultobj = SWIG_Py_Void();
15827 return resultobj;
15828 fail:
15829 return NULL;
15830 }
15831
15832
15833 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj = 0;
15835 wxGrid *arg1 = (wxGrid *) 0 ;
15836 int arg2 ;
15837 void *argp1 = 0 ;
15838 int res1 = 0 ;
15839 int val2 ;
15840 int ecode2 = 0 ;
15841 PyObject * obj0 = 0 ;
15842 PyObject * obj1 = 0 ;
15843 char * kwnames[] = {
15844 (char *) "self",(char *) "width", NULL
15845 };
15846
15847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
15848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15851 }
15852 arg1 = reinterpret_cast< wxGrid * >(argp1);
15853 ecode2 = SWIG_AsVal_int(obj1, &val2);
15854 if (!SWIG_IsOK(ecode2)) {
15855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
15856 }
15857 arg2 = static_cast< int >(val2);
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 (arg1)->SetRowMinimalAcceptableHeight(arg2);
15861 wxPyEndAllowThreads(__tstate);
15862 if (PyErr_Occurred()) SWIG_fail;
15863 }
15864 resultobj = SWIG_Py_Void();
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15872 PyObject *resultobj = 0;
15873 wxGrid *arg1 = (wxGrid *) 0 ;
15874 int result;
15875 void *argp1 = 0 ;
15876 int res1 = 0 ;
15877 PyObject *swig_obj[1] ;
15878
15879 if (!args) SWIG_fail;
15880 swig_obj[0] = args;
15881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
15884 }
15885 arg1 = reinterpret_cast< wxGrid * >(argp1);
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
15889 wxPyEndAllowThreads(__tstate);
15890 if (PyErr_Occurred()) SWIG_fail;
15891 }
15892 resultobj = SWIG_From_int(static_cast< int >(result));
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15900 PyObject *resultobj = 0;
15901 wxGrid *arg1 = (wxGrid *) 0 ;
15902 int result;
15903 void *argp1 = 0 ;
15904 int res1 = 0 ;
15905 PyObject *swig_obj[1] ;
15906
15907 if (!args) SWIG_fail;
15908 swig_obj[0] = args;
15909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15910 if (!SWIG_IsOK(res1)) {
15911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
15912 }
15913 arg1 = reinterpret_cast< wxGrid * >(argp1);
15914 {
15915 PyThreadState* __tstate = wxPyBeginAllowThreads();
15916 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
15917 wxPyEndAllowThreads(__tstate);
15918 if (PyErr_Occurred()) SWIG_fail;
15919 }
15920 resultobj = SWIG_From_int(static_cast< int >(result));
15921 return resultobj;
15922 fail:
15923 return NULL;
15924 }
15925
15926
15927 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15928 PyObject *resultobj = 0;
15929 wxGrid *arg1 = (wxGrid *) 0 ;
15930 wxColour *arg2 = 0 ;
15931 void *argp1 = 0 ;
15932 int res1 = 0 ;
15933 wxColour temp2 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 char * kwnames[] = {
15937 (char *) "self",(char *)"arg2", NULL
15938 };
15939
15940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
15941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15942 if (!SWIG_IsOK(res1)) {
15943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15944 }
15945 arg1 = reinterpret_cast< wxGrid * >(argp1);
15946 {
15947 arg2 = &temp2;
15948 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15949 }
15950 {
15951 PyThreadState* __tstate = wxPyBeginAllowThreads();
15952 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 resultobj = SWIG_Py_Void();
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj = 0;
15965 wxGrid *arg1 = (wxGrid *) 0 ;
15966 int arg2 ;
15967 int arg3 ;
15968 wxColour *arg4 = 0 ;
15969 void *argp1 = 0 ;
15970 int res1 = 0 ;
15971 int val2 ;
15972 int ecode2 = 0 ;
15973 int val3 ;
15974 int ecode3 = 0 ;
15975 wxColour temp4 ;
15976 PyObject * obj0 = 0 ;
15977 PyObject * obj1 = 0 ;
15978 PyObject * obj2 = 0 ;
15979 PyObject * obj3 = 0 ;
15980 char * kwnames[] = {
15981 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
15982 };
15983
15984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15986 if (!SWIG_IsOK(res1)) {
15987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15988 }
15989 arg1 = reinterpret_cast< wxGrid * >(argp1);
15990 ecode2 = SWIG_AsVal_int(obj1, &val2);
15991 if (!SWIG_IsOK(ecode2)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15993 }
15994 arg2 = static_cast< int >(val2);
15995 ecode3 = SWIG_AsVal_int(obj2, &val3);
15996 if (!SWIG_IsOK(ecode3)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15998 }
15999 arg3 = static_cast< int >(val3);
16000 {
16001 arg4 = &temp4;
16002 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16003 }
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_Py_Void();
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj = 0;
16019 wxGrid *arg1 = (wxGrid *) 0 ;
16020 wxColour *arg2 = 0 ;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 wxColour temp2 ;
16024 PyObject * obj0 = 0 ;
16025 PyObject * obj1 = 0 ;
16026 char * kwnames[] = {
16027 (char *) "self",(char *)"arg2", NULL
16028 };
16029
16030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16034 }
16035 arg1 = reinterpret_cast< wxGrid * >(argp1);
16036 {
16037 arg2 = &temp2;
16038 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_Py_Void();
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxGrid *arg1 = (wxGrid *) 0 ;
16056 int arg2 ;
16057 int arg3 ;
16058 wxColour *arg4 = 0 ;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 int val2 ;
16062 int ecode2 = 0 ;
16063 int val3 ;
16064 int ecode3 = 0 ;
16065 wxColour temp4 ;
16066 PyObject * obj0 = 0 ;
16067 PyObject * obj1 = 0 ;
16068 PyObject * obj2 = 0 ;
16069 PyObject * obj3 = 0 ;
16070 char * kwnames[] = {
16071 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16072 };
16073
16074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16078 }
16079 arg1 = reinterpret_cast< wxGrid * >(argp1);
16080 ecode2 = SWIG_AsVal_int(obj1, &val2);
16081 if (!SWIG_IsOK(ecode2)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16083 }
16084 arg2 = static_cast< int >(val2);
16085 ecode3 = SWIG_AsVal_int(obj2, &val3);
16086 if (!SWIG_IsOK(ecode3)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16088 }
16089 arg3 = static_cast< int >(val3);
16090 {
16091 arg4 = &temp4;
16092 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 resultobj = SWIG_Py_Void();
16101 return resultobj;
16102 fail:
16103 return NULL;
16104 }
16105
16106
16107 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj = 0;
16109 wxGrid *arg1 = (wxGrid *) 0 ;
16110 wxFont *arg2 = 0 ;
16111 void *argp1 = 0 ;
16112 int res1 = 0 ;
16113 void *argp2 = 0 ;
16114 int res2 = 0 ;
16115 PyObject * obj0 = 0 ;
16116 PyObject * obj1 = 0 ;
16117 char * kwnames[] = {
16118 (char *) "self",(char *)"arg2", NULL
16119 };
16120
16121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16125 }
16126 arg1 = reinterpret_cast< wxGrid * >(argp1);
16127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16128 if (!SWIG_IsOK(res2)) {
16129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16130 }
16131 if (!argp2) {
16132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16133 }
16134 arg2 = reinterpret_cast< wxFont * >(argp2);
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 resultobj = SWIG_Py_Void();
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj = 0;
16150 wxGrid *arg1 = (wxGrid *) 0 ;
16151 int arg2 ;
16152 int arg3 ;
16153 wxFont *arg4 = 0 ;
16154 void *argp1 = 0 ;
16155 int res1 = 0 ;
16156 int val2 ;
16157 int ecode2 = 0 ;
16158 int val3 ;
16159 int ecode3 = 0 ;
16160 void *argp4 = 0 ;
16161 int res4 = 0 ;
16162 PyObject * obj0 = 0 ;
16163 PyObject * obj1 = 0 ;
16164 PyObject * obj2 = 0 ;
16165 PyObject * obj3 = 0 ;
16166 char * kwnames[] = {
16167 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16168 };
16169
16170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16172 if (!SWIG_IsOK(res1)) {
16173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16174 }
16175 arg1 = reinterpret_cast< wxGrid * >(argp1);
16176 ecode2 = SWIG_AsVal_int(obj1, &val2);
16177 if (!SWIG_IsOK(ecode2)) {
16178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16179 }
16180 arg2 = static_cast< int >(val2);
16181 ecode3 = SWIG_AsVal_int(obj2, &val3);
16182 if (!SWIG_IsOK(ecode3)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16184 }
16185 arg3 = static_cast< int >(val3);
16186 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16187 if (!SWIG_IsOK(res4)) {
16188 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16189 }
16190 if (!argp4) {
16191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16192 }
16193 arg4 = reinterpret_cast< wxFont * >(argp4);
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_Py_Void();
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxGrid *arg1 = (wxGrid *) 0 ;
16210 int arg2 ;
16211 int arg3 ;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 int val2 ;
16215 int ecode2 = 0 ;
16216 int val3 ;
16217 int ecode3 = 0 ;
16218 PyObject * obj0 = 0 ;
16219 PyObject * obj1 = 0 ;
16220 PyObject * obj2 = 0 ;
16221 char * kwnames[] = {
16222 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16223 };
16224
16225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16227 if (!SWIG_IsOK(res1)) {
16228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16229 }
16230 arg1 = reinterpret_cast< wxGrid * >(argp1);
16231 ecode2 = SWIG_AsVal_int(obj1, &val2);
16232 if (!SWIG_IsOK(ecode2)) {
16233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16234 }
16235 arg2 = static_cast< int >(val2);
16236 ecode3 = SWIG_AsVal_int(obj2, &val3);
16237 if (!SWIG_IsOK(ecode3)) {
16238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16239 }
16240 arg3 = static_cast< int >(val3);
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 resultobj = SWIG_Py_Void();
16248 return resultobj;
16249 fail:
16250 return NULL;
16251 }
16252
16253
16254 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16255 PyObject *resultobj = 0;
16256 wxGrid *arg1 = (wxGrid *) 0 ;
16257 int arg2 ;
16258 int arg3 ;
16259 int arg4 ;
16260 int arg5 ;
16261 void *argp1 = 0 ;
16262 int res1 = 0 ;
16263 int val2 ;
16264 int ecode2 = 0 ;
16265 int val3 ;
16266 int ecode3 = 0 ;
16267 int val4 ;
16268 int ecode4 = 0 ;
16269 int val5 ;
16270 int ecode5 = 0 ;
16271 PyObject * obj0 = 0 ;
16272 PyObject * obj1 = 0 ;
16273 PyObject * obj2 = 0 ;
16274 PyObject * obj3 = 0 ;
16275 PyObject * obj4 = 0 ;
16276 char * kwnames[] = {
16277 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16278 };
16279
16280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16284 }
16285 arg1 = reinterpret_cast< wxGrid * >(argp1);
16286 ecode2 = SWIG_AsVal_int(obj1, &val2);
16287 if (!SWIG_IsOK(ecode2)) {
16288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16289 }
16290 arg2 = static_cast< int >(val2);
16291 ecode3 = SWIG_AsVal_int(obj2, &val3);
16292 if (!SWIG_IsOK(ecode3)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16294 }
16295 arg3 = static_cast< int >(val3);
16296 ecode4 = SWIG_AsVal_int(obj3, &val4);
16297 if (!SWIG_IsOK(ecode4)) {
16298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16299 }
16300 arg4 = static_cast< int >(val4);
16301 ecode5 = SWIG_AsVal_int(obj4, &val5);
16302 if (!SWIG_IsOK(ecode5)) {
16303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16304 }
16305 arg5 = static_cast< int >(val5);
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16309 wxPyEndAllowThreads(__tstate);
16310 if (PyErr_Occurred()) SWIG_fail;
16311 }
16312 resultobj = SWIG_Py_Void();
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj = 0;
16321 wxGrid *arg1 = (wxGrid *) 0 ;
16322 bool arg2 ;
16323 void *argp1 = 0 ;
16324 int res1 = 0 ;
16325 bool val2 ;
16326 int ecode2 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "allow", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16337 }
16338 arg1 = reinterpret_cast< wxGrid * >(argp1);
16339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16340 if (!SWIG_IsOK(ecode2)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16342 }
16343 arg2 = static_cast< bool >(val2);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 (arg1)->SetDefaultCellOverflow(arg2);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_Py_Void();
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxGrid *arg1 = (wxGrid *) 0 ;
16360 int arg2 ;
16361 int arg3 ;
16362 bool arg4 ;
16363 void *argp1 = 0 ;
16364 int res1 = 0 ;
16365 int val2 ;
16366 int ecode2 = 0 ;
16367 int val3 ;
16368 int ecode3 = 0 ;
16369 bool val4 ;
16370 int ecode4 = 0 ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 PyObject * obj2 = 0 ;
16374 PyObject * obj3 = 0 ;
16375 char * kwnames[] = {
16376 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16377 };
16378
16379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16381 if (!SWIG_IsOK(res1)) {
16382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16383 }
16384 arg1 = reinterpret_cast< wxGrid * >(argp1);
16385 ecode2 = SWIG_AsVal_int(obj1, &val2);
16386 if (!SWIG_IsOK(ecode2)) {
16387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16388 }
16389 arg2 = static_cast< int >(val2);
16390 ecode3 = SWIG_AsVal_int(obj2, &val3);
16391 if (!SWIG_IsOK(ecode3)) {
16392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16393 }
16394 arg3 = static_cast< int >(val3);
16395 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16396 if (!SWIG_IsOK(ecode4)) {
16397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16398 }
16399 arg4 = static_cast< bool >(val4);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_Py_Void();
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16414 PyObject *resultobj = 0;
16415 wxGrid *arg1 = (wxGrid *) 0 ;
16416 int arg2 ;
16417 int arg3 ;
16418 int arg4 ;
16419 int arg5 ;
16420 void *argp1 = 0 ;
16421 int res1 = 0 ;
16422 int val2 ;
16423 int ecode2 = 0 ;
16424 int val3 ;
16425 int ecode3 = 0 ;
16426 int val4 ;
16427 int ecode4 = 0 ;
16428 int val5 ;
16429 int ecode5 = 0 ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 PyObject * obj2 = 0 ;
16433 PyObject * obj3 = 0 ;
16434 PyObject * obj4 = 0 ;
16435 char * kwnames[] = {
16436 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16437 };
16438
16439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16443 }
16444 arg1 = reinterpret_cast< wxGrid * >(argp1);
16445 ecode2 = SWIG_AsVal_int(obj1, &val2);
16446 if (!SWIG_IsOK(ecode2)) {
16447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16448 }
16449 arg2 = static_cast< int >(val2);
16450 ecode3 = SWIG_AsVal_int(obj2, &val3);
16451 if (!SWIG_IsOK(ecode3)) {
16452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16453 }
16454 arg3 = static_cast< int >(val3);
16455 ecode4 = SWIG_AsVal_int(obj3, &val4);
16456 if (!SWIG_IsOK(ecode4)) {
16457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16458 }
16459 arg4 = static_cast< int >(val4);
16460 ecode5 = SWIG_AsVal_int(obj4, &val5);
16461 if (!SWIG_IsOK(ecode5)) {
16462 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16463 }
16464 arg5 = static_cast< int >(val5);
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_Py_Void();
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj = 0;
16480 wxGrid *arg1 = (wxGrid *) 0 ;
16481 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 void *argp2 = 0 ;
16485 int res2 = 0 ;
16486 PyObject * obj0 = 0 ;
16487 PyObject * obj1 = 0 ;
16488 char * kwnames[] = {
16489 (char *) "self",(char *) "renderer", NULL
16490 };
16491
16492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16494 if (!SWIG_IsOK(res1)) {
16495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16496 }
16497 arg1 = reinterpret_cast< wxGrid * >(argp1);
16498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16499 if (!SWIG_IsOK(res2)) {
16500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16501 }
16502 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 (arg1)->SetDefaultRenderer(arg2);
16506 wxPyEndAllowThreads(__tstate);
16507 if (PyErr_Occurred()) SWIG_fail;
16508 }
16509 resultobj = SWIG_Py_Void();
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj = 0;
16518 wxGrid *arg1 = (wxGrid *) 0 ;
16519 int arg2 ;
16520 int arg3 ;
16521 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 int val2 ;
16525 int ecode2 = 0 ;
16526 int val3 ;
16527 int ecode3 = 0 ;
16528 void *argp4 = 0 ;
16529 int res4 = 0 ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 PyObject * obj2 = 0 ;
16533 PyObject * obj3 = 0 ;
16534 char * kwnames[] = {
16535 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16536 };
16537
16538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16540 if (!SWIG_IsOK(res1)) {
16541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16542 }
16543 arg1 = reinterpret_cast< wxGrid * >(argp1);
16544 ecode2 = SWIG_AsVal_int(obj1, &val2);
16545 if (!SWIG_IsOK(ecode2)) {
16546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16547 }
16548 arg2 = static_cast< int >(val2);
16549 ecode3 = SWIG_AsVal_int(obj2, &val3);
16550 if (!SWIG_IsOK(ecode3)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16552 }
16553 arg3 = static_cast< int >(val3);
16554 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16555 if (!SWIG_IsOK(res4)) {
16556 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16557 }
16558 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 resultobj = SWIG_Py_Void();
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16573 PyObject *resultobj = 0;
16574 wxGrid *arg1 = (wxGrid *) 0 ;
16575 wxGridCellRenderer *result = 0 ;
16576 void *argp1 = 0 ;
16577 int res1 = 0 ;
16578 PyObject *swig_obj[1] ;
16579
16580 if (!args) SWIG_fail;
16581 swig_obj[0] = args;
16582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16583 if (!SWIG_IsOK(res1)) {
16584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16585 }
16586 arg1 = reinterpret_cast< wxGrid * >(argp1);
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 {
16594 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16595 }
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16603 PyObject *resultobj = 0;
16604 wxGrid *arg1 = (wxGrid *) 0 ;
16605 int arg2 ;
16606 int arg3 ;
16607 wxGridCellRenderer *result = 0 ;
16608 void *argp1 = 0 ;
16609 int res1 = 0 ;
16610 int val2 ;
16611 int ecode2 = 0 ;
16612 int val3 ;
16613 int ecode3 = 0 ;
16614 PyObject * obj0 = 0 ;
16615 PyObject * obj1 = 0 ;
16616 PyObject * obj2 = 0 ;
16617 char * kwnames[] = {
16618 (char *) "self",(char *) "row",(char *) "col", NULL
16619 };
16620
16621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16623 if (!SWIG_IsOK(res1)) {
16624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16625 }
16626 arg1 = reinterpret_cast< wxGrid * >(argp1);
16627 ecode2 = SWIG_AsVal_int(obj1, &val2);
16628 if (!SWIG_IsOK(ecode2)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16630 }
16631 arg2 = static_cast< int >(val2);
16632 ecode3 = SWIG_AsVal_int(obj2, &val3);
16633 if (!SWIG_IsOK(ecode3)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16635 }
16636 arg3 = static_cast< int >(val3);
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxGrid *arg1 = (wxGrid *) 0 ;
16655 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16656 void *argp1 = 0 ;
16657 int res1 = 0 ;
16658 void *argp2 = 0 ;
16659 int res2 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 char * kwnames[] = {
16663 (char *) "self",(char *) "editor", NULL
16664 };
16665
16666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16670 }
16671 arg1 = reinterpret_cast< wxGrid * >(argp1);
16672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16673 if (!SWIG_IsOK(res2)) {
16674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16675 }
16676 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 (arg1)->SetDefaultEditor(arg2);
16680 wxPyEndAllowThreads(__tstate);
16681 if (PyErr_Occurred()) SWIG_fail;
16682 }
16683 resultobj = SWIG_Py_Void();
16684 return resultobj;
16685 fail:
16686 return NULL;
16687 }
16688
16689
16690 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16691 PyObject *resultobj = 0;
16692 wxGrid *arg1 = (wxGrid *) 0 ;
16693 int arg2 ;
16694 int arg3 ;
16695 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 int val2 ;
16699 int ecode2 = 0 ;
16700 int val3 ;
16701 int ecode3 = 0 ;
16702 void *argp4 = 0 ;
16703 int res4 = 0 ;
16704 PyObject * obj0 = 0 ;
16705 PyObject * obj1 = 0 ;
16706 PyObject * obj2 = 0 ;
16707 PyObject * obj3 = 0 ;
16708 char * kwnames[] = {
16709 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16710 };
16711
16712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16714 if (!SWIG_IsOK(res1)) {
16715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16716 }
16717 arg1 = reinterpret_cast< wxGrid * >(argp1);
16718 ecode2 = SWIG_AsVal_int(obj1, &val2);
16719 if (!SWIG_IsOK(ecode2)) {
16720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16721 }
16722 arg2 = static_cast< int >(val2);
16723 ecode3 = SWIG_AsVal_int(obj2, &val3);
16724 if (!SWIG_IsOK(ecode3)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16726 }
16727 arg3 = static_cast< int >(val3);
16728 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16729 if (!SWIG_IsOK(res4)) {
16730 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16731 }
16732 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 (arg1)->SetCellEditor(arg2,arg3,arg4);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_Py_Void();
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16747 PyObject *resultobj = 0;
16748 wxGrid *arg1 = (wxGrid *) 0 ;
16749 wxGridCellEditor *result = 0 ;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 PyObject *swig_obj[1] ;
16753
16754 if (!args) SWIG_fail;
16755 swig_obj[0] = args;
16756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16759 }
16760 arg1 = reinterpret_cast< wxGrid * >(argp1);
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16769 }
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj = 0;
16778 wxGrid *arg1 = (wxGrid *) 0 ;
16779 int arg2 ;
16780 int arg3 ;
16781 wxGridCellEditor *result = 0 ;
16782 void *argp1 = 0 ;
16783 int res1 = 0 ;
16784 int val2 ;
16785 int ecode2 = 0 ;
16786 int val3 ;
16787 int ecode3 = 0 ;
16788 PyObject * obj0 = 0 ;
16789 PyObject * obj1 = 0 ;
16790 PyObject * obj2 = 0 ;
16791 char * kwnames[] = {
16792 (char *) "self",(char *) "row",(char *) "col", NULL
16793 };
16794
16795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16797 if (!SWIG_IsOK(res1)) {
16798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16799 }
16800 arg1 = reinterpret_cast< wxGrid * >(argp1);
16801 ecode2 = SWIG_AsVal_int(obj1, &val2);
16802 if (!SWIG_IsOK(ecode2)) {
16803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
16804 }
16805 arg2 = static_cast< int >(val2);
16806 ecode3 = SWIG_AsVal_int(obj2, &val3);
16807 if (!SWIG_IsOK(ecode3)) {
16808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
16809 }
16810 arg3 = static_cast< int >(val3);
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 {
16818 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16819 }
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj = 0;
16828 wxGrid *arg1 = (wxGrid *) 0 ;
16829 int arg2 ;
16830 int arg3 ;
16831 wxString result;
16832 void *argp1 = 0 ;
16833 int res1 = 0 ;
16834 int val2 ;
16835 int ecode2 = 0 ;
16836 int val3 ;
16837 int ecode3 = 0 ;
16838 PyObject * obj0 = 0 ;
16839 PyObject * obj1 = 0 ;
16840 PyObject * obj2 = 0 ;
16841 char * kwnames[] = {
16842 (char *) "self",(char *) "row",(char *) "col", NULL
16843 };
16844
16845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16847 if (!SWIG_IsOK(res1)) {
16848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16849 }
16850 arg1 = reinterpret_cast< wxGrid * >(argp1);
16851 ecode2 = SWIG_AsVal_int(obj1, &val2);
16852 if (!SWIG_IsOK(ecode2)) {
16853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
16854 }
16855 arg2 = static_cast< int >(val2);
16856 ecode3 = SWIG_AsVal_int(obj2, &val3);
16857 if (!SWIG_IsOK(ecode3)) {
16858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
16859 }
16860 arg3 = static_cast< int >(val3);
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 result = (arg1)->GetCellValue(arg2,arg3);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 #if wxUSE_UNICODE
16869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16870 #else
16871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16872 #endif
16873 }
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj = 0;
16882 wxGrid *arg1 = (wxGrid *) 0 ;
16883 int arg2 ;
16884 int arg3 ;
16885 wxString *arg4 = 0 ;
16886 void *argp1 = 0 ;
16887 int res1 = 0 ;
16888 int val2 ;
16889 int ecode2 = 0 ;
16890 int val3 ;
16891 int ecode3 = 0 ;
16892 bool temp4 = false ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 PyObject * obj2 = 0 ;
16896 PyObject * obj3 = 0 ;
16897 char * kwnames[] = {
16898 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
16899 };
16900
16901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16903 if (!SWIG_IsOK(res1)) {
16904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16905 }
16906 arg1 = reinterpret_cast< wxGrid * >(argp1);
16907 ecode2 = SWIG_AsVal_int(obj1, &val2);
16908 if (!SWIG_IsOK(ecode2)) {
16909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
16910 }
16911 arg2 = static_cast< int >(val2);
16912 ecode3 = SWIG_AsVal_int(obj2, &val3);
16913 if (!SWIG_IsOK(ecode3)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
16915 }
16916 arg3 = static_cast< int >(val3);
16917 {
16918 arg4 = wxString_in_helper(obj3);
16919 if (arg4 == NULL) SWIG_fail;
16920 temp4 = true;
16921 }
16922 {
16923 PyThreadState* __tstate = wxPyBeginAllowThreads();
16924 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 resultobj = SWIG_Py_Void();
16929 {
16930 if (temp4)
16931 delete arg4;
16932 }
16933 return resultobj;
16934 fail:
16935 {
16936 if (temp4)
16937 delete arg4;
16938 }
16939 return NULL;
16940 }
16941
16942
16943 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj = 0;
16945 wxGrid *arg1 = (wxGrid *) 0 ;
16946 int arg2 ;
16947 int arg3 ;
16948 bool result;
16949 void *argp1 = 0 ;
16950 int res1 = 0 ;
16951 int val2 ;
16952 int ecode2 = 0 ;
16953 int val3 ;
16954 int ecode3 = 0 ;
16955 PyObject * obj0 = 0 ;
16956 PyObject * obj1 = 0 ;
16957 PyObject * obj2 = 0 ;
16958 char * kwnames[] = {
16959 (char *) "self",(char *) "row",(char *) "col", NULL
16960 };
16961
16962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16964 if (!SWIG_IsOK(res1)) {
16965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
16966 }
16967 arg1 = reinterpret_cast< wxGrid * >(argp1);
16968 ecode2 = SWIG_AsVal_int(obj1, &val2);
16969 if (!SWIG_IsOK(ecode2)) {
16970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
16971 }
16972 arg2 = static_cast< int >(val2);
16973 ecode3 = SWIG_AsVal_int(obj2, &val3);
16974 if (!SWIG_IsOK(ecode3)) {
16975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
16976 }
16977 arg3 = static_cast< int >(val3);
16978 {
16979 PyThreadState* __tstate = wxPyBeginAllowThreads();
16980 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 {
16985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16986 }
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 wxGrid *arg1 = (wxGrid *) 0 ;
16996 int arg2 ;
16997 int arg3 ;
16998 bool arg4 = (bool) true ;
16999 void *argp1 = 0 ;
17000 int res1 = 0 ;
17001 int val2 ;
17002 int ecode2 = 0 ;
17003 int val3 ;
17004 int ecode3 = 0 ;
17005 bool val4 ;
17006 int ecode4 = 0 ;
17007 PyObject * obj0 = 0 ;
17008 PyObject * obj1 = 0 ;
17009 PyObject * obj2 = 0 ;
17010 PyObject * obj3 = 0 ;
17011 char * kwnames[] = {
17012 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17013 };
17014
17015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17017 if (!SWIG_IsOK(res1)) {
17018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17019 }
17020 arg1 = reinterpret_cast< wxGrid * >(argp1);
17021 ecode2 = SWIG_AsVal_int(obj1, &val2);
17022 if (!SWIG_IsOK(ecode2)) {
17023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17024 }
17025 arg2 = static_cast< int >(val2);
17026 ecode3 = SWIG_AsVal_int(obj2, &val3);
17027 if (!SWIG_IsOK(ecode3)) {
17028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17029 }
17030 arg3 = static_cast< int >(val3);
17031 if (obj3) {
17032 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17033 if (!SWIG_IsOK(ecode4)) {
17034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17035 }
17036 arg4 = static_cast< bool >(val4);
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 (arg1)->SetReadOnly(arg2,arg3,arg4);
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 resultobj = SWIG_Py_Void();
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 wxGrid *arg1 = (wxGrid *) 0 ;
17054 int arg2 ;
17055 bool arg3 = (bool) false ;
17056 void *argp1 = 0 ;
17057 int res1 = 0 ;
17058 int val2 ;
17059 int ecode2 = 0 ;
17060 bool val3 ;
17061 int ecode3 = 0 ;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 PyObject * obj2 = 0 ;
17065 char * kwnames[] = {
17066 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17067 };
17068
17069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17071 if (!SWIG_IsOK(res1)) {
17072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17073 }
17074 arg1 = reinterpret_cast< wxGrid * >(argp1);
17075 ecode2 = SWIG_AsVal_int(obj1, &val2);
17076 if (!SWIG_IsOK(ecode2)) {
17077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17078 }
17079 arg2 = static_cast< int >(val2);
17080 if (obj2) {
17081 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17082 if (!SWIG_IsOK(ecode3)) {
17083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17084 }
17085 arg3 = static_cast< bool >(val3);
17086 }
17087 {
17088 PyThreadState* __tstate = wxPyBeginAllowThreads();
17089 (arg1)->SelectRow(arg2,arg3);
17090 wxPyEndAllowThreads(__tstate);
17091 if (PyErr_Occurred()) SWIG_fail;
17092 }
17093 resultobj = SWIG_Py_Void();
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj = 0;
17102 wxGrid *arg1 = (wxGrid *) 0 ;
17103 int arg2 ;
17104 bool arg3 = (bool) false ;
17105 void *argp1 = 0 ;
17106 int res1 = 0 ;
17107 int val2 ;
17108 int ecode2 = 0 ;
17109 bool val3 ;
17110 int ecode3 = 0 ;
17111 PyObject * obj0 = 0 ;
17112 PyObject * obj1 = 0 ;
17113 PyObject * obj2 = 0 ;
17114 char * kwnames[] = {
17115 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17116 };
17117
17118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17120 if (!SWIG_IsOK(res1)) {
17121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17122 }
17123 arg1 = reinterpret_cast< wxGrid * >(argp1);
17124 ecode2 = SWIG_AsVal_int(obj1, &val2);
17125 if (!SWIG_IsOK(ecode2)) {
17126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17127 }
17128 arg2 = static_cast< int >(val2);
17129 if (obj2) {
17130 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17131 if (!SWIG_IsOK(ecode3)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17133 }
17134 arg3 = static_cast< bool >(val3);
17135 }
17136 {
17137 PyThreadState* __tstate = wxPyBeginAllowThreads();
17138 (arg1)->SelectCol(arg2,arg3);
17139 wxPyEndAllowThreads(__tstate);
17140 if (PyErr_Occurred()) SWIG_fail;
17141 }
17142 resultobj = SWIG_Py_Void();
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj = 0;
17151 wxGrid *arg1 = (wxGrid *) 0 ;
17152 int arg2 ;
17153 int arg3 ;
17154 int arg4 ;
17155 int arg5 ;
17156 bool arg6 = (bool) false ;
17157 void *argp1 = 0 ;
17158 int res1 = 0 ;
17159 int val2 ;
17160 int ecode2 = 0 ;
17161 int val3 ;
17162 int ecode3 = 0 ;
17163 int val4 ;
17164 int ecode4 = 0 ;
17165 int val5 ;
17166 int ecode5 = 0 ;
17167 bool val6 ;
17168 int ecode6 = 0 ;
17169 PyObject * obj0 = 0 ;
17170 PyObject * obj1 = 0 ;
17171 PyObject * obj2 = 0 ;
17172 PyObject * obj3 = 0 ;
17173 PyObject * obj4 = 0 ;
17174 PyObject * obj5 = 0 ;
17175 char * kwnames[] = {
17176 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17177 };
17178
17179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17181 if (!SWIG_IsOK(res1)) {
17182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17183 }
17184 arg1 = reinterpret_cast< wxGrid * >(argp1);
17185 ecode2 = SWIG_AsVal_int(obj1, &val2);
17186 if (!SWIG_IsOK(ecode2)) {
17187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17188 }
17189 arg2 = static_cast< int >(val2);
17190 ecode3 = SWIG_AsVal_int(obj2, &val3);
17191 if (!SWIG_IsOK(ecode3)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17193 }
17194 arg3 = static_cast< int >(val3);
17195 ecode4 = SWIG_AsVal_int(obj3, &val4);
17196 if (!SWIG_IsOK(ecode4)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17198 }
17199 arg4 = static_cast< int >(val4);
17200 ecode5 = SWIG_AsVal_int(obj4, &val5);
17201 if (!SWIG_IsOK(ecode5)) {
17202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17203 }
17204 arg5 = static_cast< int >(val5);
17205 if (obj5) {
17206 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17207 if (!SWIG_IsOK(ecode6)) {
17208 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17209 }
17210 arg6 = static_cast< bool >(val6);
17211 }
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = SWIG_Py_Void();
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *resultobj = 0;
17227 wxGrid *arg1 = (wxGrid *) 0 ;
17228 void *argp1 = 0 ;
17229 int res1 = 0 ;
17230 PyObject *swig_obj[1] ;
17231
17232 if (!args) SWIG_fail;
17233 swig_obj[0] = args;
17234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17235 if (!SWIG_IsOK(res1)) {
17236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17237 }
17238 arg1 = reinterpret_cast< wxGrid * >(argp1);
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 (arg1)->SelectAll();
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 resultobj = SWIG_Py_Void();
17246 return resultobj;
17247 fail:
17248 return NULL;
17249 }
17250
17251
17252 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17253 PyObject *resultobj = 0;
17254 wxGrid *arg1 = (wxGrid *) 0 ;
17255 bool result;
17256 void *argp1 = 0 ;
17257 int res1 = 0 ;
17258 PyObject *swig_obj[1] ;
17259
17260 if (!args) SWIG_fail;
17261 swig_obj[0] = args;
17262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17263 if (!SWIG_IsOK(res1)) {
17264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17265 }
17266 arg1 = reinterpret_cast< wxGrid * >(argp1);
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)(arg1)->IsSelection();
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17283 PyObject *resultobj = 0;
17284 wxGrid *arg1 = (wxGrid *) 0 ;
17285 void *argp1 = 0 ;
17286 int res1 = 0 ;
17287 PyObject *swig_obj[1] ;
17288
17289 if (!args) SWIG_fail;
17290 swig_obj[0] = args;
17291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17292 if (!SWIG_IsOK(res1)) {
17293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17294 }
17295 arg1 = reinterpret_cast< wxGrid * >(argp1);
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 (arg1)->ClearSelection();
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 resultobj = SWIG_Py_Void();
17303 return resultobj;
17304 fail:
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxGrid *arg1 = (wxGrid *) 0 ;
17312 int arg2 ;
17313 int arg3 ;
17314 bool result;
17315 void *argp1 = 0 ;
17316 int res1 = 0 ;
17317 int val2 ;
17318 int ecode2 = 0 ;
17319 int val3 ;
17320 int ecode3 = 0 ;
17321 PyObject * obj0 = 0 ;
17322 PyObject * obj1 = 0 ;
17323 PyObject * obj2 = 0 ;
17324 char * kwnames[] = {
17325 (char *) "self",(char *) "row",(char *) "col", NULL
17326 };
17327
17328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17330 if (!SWIG_IsOK(res1)) {
17331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17332 }
17333 arg1 = reinterpret_cast< wxGrid * >(argp1);
17334 ecode2 = SWIG_AsVal_int(obj1, &val2);
17335 if (!SWIG_IsOK(ecode2)) {
17336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17337 }
17338 arg2 = static_cast< int >(val2);
17339 ecode3 = SWIG_AsVal_int(obj2, &val3);
17340 if (!SWIG_IsOK(ecode3)) {
17341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17342 }
17343 arg3 = static_cast< int >(val3);
17344 {
17345 PyThreadState* __tstate = wxPyBeginAllowThreads();
17346 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17347 wxPyEndAllowThreads(__tstate);
17348 if (PyErr_Occurred()) SWIG_fail;
17349 }
17350 {
17351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17352 }
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17360 PyObject *resultobj = 0;
17361 wxGrid *arg1 = (wxGrid *) 0 ;
17362 wxGridCellCoordsArray result;
17363 void *argp1 = 0 ;
17364 int res1 = 0 ;
17365 PyObject *swig_obj[1] ;
17366
17367 if (!args) SWIG_fail;
17368 swig_obj[0] = args;
17369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17370 if (!SWIG_IsOK(res1)) {
17371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17372 }
17373 arg1 = reinterpret_cast< wxGrid * >(argp1);
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = ((wxGrid const *)arg1)->GetSelectedCells();
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 {
17381 resultobj = wxGridCellCoordsArray_helper(result);
17382 }
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17390 PyObject *resultobj = 0;
17391 wxGrid *arg1 = (wxGrid *) 0 ;
17392 wxGridCellCoordsArray result;
17393 void *argp1 = 0 ;
17394 int res1 = 0 ;
17395 PyObject *swig_obj[1] ;
17396
17397 if (!args) SWIG_fail;
17398 swig_obj[0] = args;
17399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17400 if (!SWIG_IsOK(res1)) {
17401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17402 }
17403 arg1 = reinterpret_cast< wxGrid * >(argp1);
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = wxGridCellCoordsArray_helper(result);
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17420 PyObject *resultobj = 0;
17421 wxGrid *arg1 = (wxGrid *) 0 ;
17422 wxGridCellCoordsArray result;
17423 void *argp1 = 0 ;
17424 int res1 = 0 ;
17425 PyObject *swig_obj[1] ;
17426
17427 if (!args) SWIG_fail;
17428 swig_obj[0] = args;
17429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17430 if (!SWIG_IsOK(res1)) {
17431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17432 }
17433 arg1 = reinterpret_cast< wxGrid * >(argp1);
17434 {
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 {
17441 resultobj = wxGridCellCoordsArray_helper(result);
17442 }
17443 return resultobj;
17444 fail:
17445 return NULL;
17446 }
17447
17448
17449 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 PyObject *resultobj = 0;
17451 wxGrid *arg1 = (wxGrid *) 0 ;
17452 wxArrayInt result;
17453 void *argp1 = 0 ;
17454 int res1 = 0 ;
17455 PyObject *swig_obj[1] ;
17456
17457 if (!args) SWIG_fail;
17458 swig_obj[0] = args;
17459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17460 if (!SWIG_IsOK(res1)) {
17461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17462 }
17463 arg1 = reinterpret_cast< wxGrid * >(argp1);
17464 {
17465 PyThreadState* __tstate = wxPyBeginAllowThreads();
17466 result = ((wxGrid const *)arg1)->GetSelectedRows();
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 {
17471 resultobj = PyList_New(0);
17472 size_t idx;
17473 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17474 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17475 PyList_Append(resultobj, val);
17476 Py_DECREF(val);
17477 }
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *resultobj = 0;
17487 wxGrid *arg1 = (wxGrid *) 0 ;
17488 wxArrayInt result;
17489 void *argp1 = 0 ;
17490 int res1 = 0 ;
17491 PyObject *swig_obj[1] ;
17492
17493 if (!args) SWIG_fail;
17494 swig_obj[0] = args;
17495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17496 if (!SWIG_IsOK(res1)) {
17497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17498 }
17499 arg1 = reinterpret_cast< wxGrid * >(argp1);
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = ((wxGrid const *)arg1)->GetSelectedCols();
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 resultobj = PyList_New(0);
17508 size_t idx;
17509 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17510 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17511 PyList_Append(resultobj, val);
17512 Py_DECREF(val);
17513 }
17514 }
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17522 PyObject *resultobj = 0;
17523 wxGrid *arg1 = (wxGrid *) 0 ;
17524 int arg2 ;
17525 void *argp1 = 0 ;
17526 int res1 = 0 ;
17527 int val2 ;
17528 int ecode2 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "row", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17539 }
17540 arg1 = reinterpret_cast< wxGrid * >(argp1);
17541 ecode2 = SWIG_AsVal_int(obj1, &val2);
17542 if (!SWIG_IsOK(ecode2)) {
17543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17544 }
17545 arg2 = static_cast< int >(val2);
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 (arg1)->DeselectRow(arg2);
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 resultobj = SWIG_Py_Void();
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxGrid *arg1 = (wxGrid *) 0 ;
17562 int arg2 ;
17563 void *argp1 = 0 ;
17564 int res1 = 0 ;
17565 int val2 ;
17566 int ecode2 = 0 ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "self",(char *) "col", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17577 }
17578 arg1 = reinterpret_cast< wxGrid * >(argp1);
17579 ecode2 = SWIG_AsVal_int(obj1, &val2);
17580 if (!SWIG_IsOK(ecode2)) {
17581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17582 }
17583 arg2 = static_cast< int >(val2);
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 (arg1)->DeselectCol(arg2);
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 resultobj = SWIG_Py_Void();
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = 0;
17599 wxGrid *arg1 = (wxGrid *) 0 ;
17600 int arg2 ;
17601 int arg3 ;
17602 void *argp1 = 0 ;
17603 int res1 = 0 ;
17604 int val2 ;
17605 int ecode2 = 0 ;
17606 int val3 ;
17607 int ecode3 = 0 ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 PyObject * obj2 = 0 ;
17611 char * kwnames[] = {
17612 (char *) "self",(char *) "row",(char *) "col", NULL
17613 };
17614
17615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17617 if (!SWIG_IsOK(res1)) {
17618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17619 }
17620 arg1 = reinterpret_cast< wxGrid * >(argp1);
17621 ecode2 = SWIG_AsVal_int(obj1, &val2);
17622 if (!SWIG_IsOK(ecode2)) {
17623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17624 }
17625 arg2 = static_cast< int >(val2);
17626 ecode3 = SWIG_AsVal_int(obj2, &val3);
17627 if (!SWIG_IsOK(ecode3)) {
17628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17629 }
17630 arg3 = static_cast< int >(val3);
17631 {
17632 PyThreadState* __tstate = wxPyBeginAllowThreads();
17633 (arg1)->DeselectCell(arg2,arg3);
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 resultobj = SWIG_Py_Void();
17638 return resultobj;
17639 fail:
17640 return NULL;
17641 }
17642
17643
17644 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17645 PyObject *resultobj = 0;
17646 wxGrid *arg1 = (wxGrid *) 0 ;
17647 wxGridCellCoords *arg2 = 0 ;
17648 wxGridCellCoords *arg3 = 0 ;
17649 wxRect result;
17650 void *argp1 = 0 ;
17651 int res1 = 0 ;
17652 wxGridCellCoords temp2 ;
17653 wxGridCellCoords temp3 ;
17654 PyObject * obj0 = 0 ;
17655 PyObject * obj1 = 0 ;
17656 PyObject * obj2 = 0 ;
17657 char * kwnames[] = {
17658 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17659 };
17660
17661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17663 if (!SWIG_IsOK(res1)) {
17664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17665 }
17666 arg1 = reinterpret_cast< wxGrid * >(argp1);
17667 {
17668 arg2 = &temp2;
17669 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17670 }
17671 {
17672 arg3 = &temp3;
17673 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17674 }
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxGrid *arg1 = (wxGrid *) 0 ;
17691 wxColour result;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 PyObject *swig_obj[1] ;
17695
17696 if (!args) SWIG_fail;
17697 swig_obj[0] = args;
17698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17701 }
17702 arg1 = reinterpret_cast< wxGrid * >(argp1);
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17717 PyObject *resultobj = 0;
17718 wxGrid *arg1 = (wxGrid *) 0 ;
17719 wxColour result;
17720 void *argp1 = 0 ;
17721 int res1 = 0 ;
17722 PyObject *swig_obj[1] ;
17723
17724 if (!args) SWIG_fail;
17725 swig_obj[0] = args;
17726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17727 if (!SWIG_IsOK(res1)) {
17728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17729 }
17730 arg1 = reinterpret_cast< wxGrid * >(argp1);
17731 {
17732 PyThreadState* __tstate = wxPyBeginAllowThreads();
17733 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17738 return resultobj;
17739 fail:
17740 return NULL;
17741 }
17742
17743
17744 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj = 0;
17746 wxGrid *arg1 = (wxGrid *) 0 ;
17747 wxColour *arg2 = 0 ;
17748 void *argp1 = 0 ;
17749 int res1 = 0 ;
17750 wxColour temp2 ;
17751 PyObject * obj0 = 0 ;
17752 PyObject * obj1 = 0 ;
17753 char * kwnames[] = {
17754 (char *) "self",(char *) "c", NULL
17755 };
17756
17757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17759 if (!SWIG_IsOK(res1)) {
17760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
17761 }
17762 arg1 = reinterpret_cast< wxGrid * >(argp1);
17763 {
17764 arg2 = &temp2;
17765 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17766 }
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 resultobj = SWIG_Py_Void();
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj = 0;
17782 wxGrid *arg1 = (wxGrid *) 0 ;
17783 wxColour *arg2 = 0 ;
17784 void *argp1 = 0 ;
17785 int res1 = 0 ;
17786 wxColour temp2 ;
17787 PyObject * obj0 = 0 ;
17788 PyObject * obj1 = 0 ;
17789 char * kwnames[] = {
17790 (char *) "self",(char *) "c", NULL
17791 };
17792
17793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
17794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17795 if (!SWIG_IsOK(res1)) {
17796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
17797 }
17798 arg1 = reinterpret_cast< wxGrid * >(argp1);
17799 {
17800 arg2 = &temp2;
17801 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17802 }
17803 {
17804 PyThreadState* __tstate = wxPyBeginAllowThreads();
17805 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
17806 wxPyEndAllowThreads(__tstate);
17807 if (PyErr_Occurred()) SWIG_fail;
17808 }
17809 resultobj = SWIG_Py_Void();
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17817 PyObject *resultobj = 0;
17818 wxGrid *arg1 = (wxGrid *) 0 ;
17819 wxString *arg2 = 0 ;
17820 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
17821 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 bool temp2 = false ;
17825 void *argp3 = 0 ;
17826 int res3 = 0 ;
17827 void *argp4 = 0 ;
17828 int res4 = 0 ;
17829 PyObject * obj0 = 0 ;
17830 PyObject * obj1 = 0 ;
17831 PyObject * obj2 = 0 ;
17832 PyObject * obj3 = 0 ;
17833 char * kwnames[] = {
17834 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
17835 };
17836
17837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17839 if (!SWIG_IsOK(res1)) {
17840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
17841 }
17842 arg1 = reinterpret_cast< wxGrid * >(argp1);
17843 {
17844 arg2 = wxString_in_helper(obj1);
17845 if (arg2 == NULL) SWIG_fail;
17846 temp2 = true;
17847 }
17848 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17849 if (!SWIG_IsOK(res3)) {
17850 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
17851 }
17852 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
17853 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17854 if (!SWIG_IsOK(res4)) {
17855 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17856 }
17857 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 resultobj = SWIG_Py_Void();
17865 {
17866 if (temp2)
17867 delete arg2;
17868 }
17869 return resultobj;
17870 fail:
17871 {
17872 if (temp2)
17873 delete arg2;
17874 }
17875 return NULL;
17876 }
17877
17878
17879 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17880 PyObject *resultobj = 0;
17881 wxGrid *arg1 = (wxGrid *) 0 ;
17882 int arg2 ;
17883 int arg3 ;
17884 wxGridCellEditor *result = 0 ;
17885 void *argp1 = 0 ;
17886 int res1 = 0 ;
17887 int val2 ;
17888 int ecode2 = 0 ;
17889 int val3 ;
17890 int ecode3 = 0 ;
17891 PyObject * obj0 = 0 ;
17892 PyObject * obj1 = 0 ;
17893 PyObject * obj2 = 0 ;
17894 char * kwnames[] = {
17895 (char *) "self",(char *) "row",(char *) "col", NULL
17896 };
17897
17898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17902 }
17903 arg1 = reinterpret_cast< wxGrid * >(argp1);
17904 ecode2 = SWIG_AsVal_int(obj1, &val2);
17905 if (!SWIG_IsOK(ecode2)) {
17906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
17907 }
17908 arg2 = static_cast< int >(val2);
17909 ecode3 = SWIG_AsVal_int(obj2, &val3);
17910 if (!SWIG_IsOK(ecode3)) {
17911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
17912 }
17913 arg3 = static_cast< int >(val3);
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 {
17921 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17922 }
17923 return resultobj;
17924 fail:
17925 return NULL;
17926 }
17927
17928
17929 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17930 PyObject *resultobj = 0;
17931 wxGrid *arg1 = (wxGrid *) 0 ;
17932 int arg2 ;
17933 int arg3 ;
17934 wxGridCellRenderer *result = 0 ;
17935 void *argp1 = 0 ;
17936 int res1 = 0 ;
17937 int val2 ;
17938 int ecode2 = 0 ;
17939 int val3 ;
17940 int ecode3 = 0 ;
17941 PyObject * obj0 = 0 ;
17942 PyObject * obj1 = 0 ;
17943 PyObject * obj2 = 0 ;
17944 char * kwnames[] = {
17945 (char *) "self",(char *) "row",(char *) "col", NULL
17946 };
17947
17948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17950 if (!SWIG_IsOK(res1)) {
17951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17952 }
17953 arg1 = reinterpret_cast< wxGrid * >(argp1);
17954 ecode2 = SWIG_AsVal_int(obj1, &val2);
17955 if (!SWIG_IsOK(ecode2)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
17957 }
17958 arg2 = static_cast< int >(val2);
17959 ecode3 = SWIG_AsVal_int(obj2, &val3);
17960 if (!SWIG_IsOK(ecode3)) {
17961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
17962 }
17963 arg3 = static_cast< int >(val3);
17964 {
17965 PyThreadState* __tstate = wxPyBeginAllowThreads();
17966 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 {
17971 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17980 PyObject *resultobj = 0;
17981 wxGrid *arg1 = (wxGrid *) 0 ;
17982 wxString *arg2 = 0 ;
17983 wxGridCellEditor *result = 0 ;
17984 void *argp1 = 0 ;
17985 int res1 = 0 ;
17986 bool temp2 = false ;
17987 PyObject * obj0 = 0 ;
17988 PyObject * obj1 = 0 ;
17989 char * kwnames[] = {
17990 (char *) "self",(char *) "typeName", NULL
17991 };
17992
17993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
17994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17995 if (!SWIG_IsOK(res1)) {
17996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
17997 }
17998 arg1 = reinterpret_cast< wxGrid * >(argp1);
17999 {
18000 arg2 = wxString_in_helper(obj1);
18001 if (arg2 == NULL) SWIG_fail;
18002 temp2 = true;
18003 }
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 {
18011 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18012 }
18013 {
18014 if (temp2)
18015 delete arg2;
18016 }
18017 return resultobj;
18018 fail:
18019 {
18020 if (temp2)
18021 delete arg2;
18022 }
18023 return NULL;
18024 }
18025
18026
18027 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18028 PyObject *resultobj = 0;
18029 wxGrid *arg1 = (wxGrid *) 0 ;
18030 wxString *arg2 = 0 ;
18031 wxGridCellRenderer *result = 0 ;
18032 void *argp1 = 0 ;
18033 int res1 = 0 ;
18034 bool temp2 = false ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char * kwnames[] = {
18038 (char *) "self",(char *) "typeName", NULL
18039 };
18040
18041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18045 }
18046 arg1 = reinterpret_cast< wxGrid * >(argp1);
18047 {
18048 arg2 = wxString_in_helper(obj1);
18049 if (arg2 == NULL) SWIG_fail;
18050 temp2 = true;
18051 }
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 {
18059 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18060 }
18061 {
18062 if (temp2)
18063 delete arg2;
18064 }
18065 return resultobj;
18066 fail:
18067 {
18068 if (temp2)
18069 delete arg2;
18070 }
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18076 PyObject *resultobj = 0;
18077 wxGrid *arg1 = (wxGrid *) 0 ;
18078 int arg2 ;
18079 int arg3 ;
18080 void *argp1 = 0 ;
18081 int res1 = 0 ;
18082 int val2 ;
18083 int ecode2 = 0 ;
18084 int val3 ;
18085 int ecode3 = 0 ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 PyObject * obj2 = 0 ;
18089 char * kwnames[] = {
18090 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18091 };
18092
18093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18095 if (!SWIG_IsOK(res1)) {
18096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18097 }
18098 arg1 = reinterpret_cast< wxGrid * >(argp1);
18099 ecode2 = SWIG_AsVal_int(obj1, &val2);
18100 if (!SWIG_IsOK(ecode2)) {
18101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18102 }
18103 arg2 = static_cast< int >(val2);
18104 ecode3 = SWIG_AsVal_int(obj2, &val3);
18105 if (!SWIG_IsOK(ecode3)) {
18106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18107 }
18108 arg3 = static_cast< int >(val3);
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 (arg1)->SetMargins(arg2,arg3);
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 resultobj = SWIG_Py_Void();
18116 return resultobj;
18117 fail:
18118 return NULL;
18119 }
18120
18121
18122 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18123 PyObject *resultobj = 0;
18124 wxGrid *arg1 = (wxGrid *) 0 ;
18125 wxWindow *result = 0 ;
18126 void *argp1 = 0 ;
18127 int res1 = 0 ;
18128 PyObject *swig_obj[1] ;
18129
18130 if (!args) SWIG_fail;
18131 swig_obj[0] = args;
18132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18133 if (!SWIG_IsOK(res1)) {
18134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18135 }
18136 arg1 = reinterpret_cast< wxGrid * >(argp1);
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (wxWindow *)(arg1)->GetGridWindow();
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 {
18144 resultobj = wxPyMake_wxObject(result, 0);
18145 }
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18153 PyObject *resultobj = 0;
18154 wxGrid *arg1 = (wxGrid *) 0 ;
18155 wxWindow *result = 0 ;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 PyObject *swig_obj[1] ;
18159
18160 if (!args) SWIG_fail;
18161 swig_obj[0] = args;
18162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18165 }
18166 arg1 = reinterpret_cast< wxGrid * >(argp1);
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 {
18174 resultobj = wxPyMake_wxObject(result, 0);
18175 }
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxGrid *arg1 = (wxGrid *) 0 ;
18185 wxWindow *result = 0 ;
18186 void *argp1 = 0 ;
18187 int res1 = 0 ;
18188 PyObject *swig_obj[1] ;
18189
18190 if (!args) SWIG_fail;
18191 swig_obj[0] = args;
18192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18195 }
18196 arg1 = reinterpret_cast< wxGrid * >(argp1);
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 {
18204 resultobj = wxPyMake_wxObject(result, 0);
18205 }
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18213 PyObject *resultobj = 0;
18214 wxGrid *arg1 = (wxGrid *) 0 ;
18215 wxWindow *result = 0 ;
18216 void *argp1 = 0 ;
18217 int res1 = 0 ;
18218 PyObject *swig_obj[1] ;
18219
18220 if (!args) SWIG_fail;
18221 swig_obj[0] = args;
18222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18223 if (!SWIG_IsOK(res1)) {
18224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18225 }
18226 arg1 = reinterpret_cast< wxGrid * >(argp1);
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18230 wxPyEndAllowThreads(__tstate);
18231 if (PyErr_Occurred()) SWIG_fail;
18232 }
18233 {
18234 resultobj = wxPyMake_wxObject(result, 0);
18235 }
18236 return resultobj;
18237 fail:
18238 return NULL;
18239 }
18240
18241
18242 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18243 PyObject *resultobj = 0;
18244 wxGrid *arg1 = (wxGrid *) 0 ;
18245 int arg2 ;
18246 void *argp1 = 0 ;
18247 int res1 = 0 ;
18248 int val2 ;
18249 int ecode2 = 0 ;
18250 PyObject * obj0 = 0 ;
18251 PyObject * obj1 = 0 ;
18252 char * kwnames[] = {
18253 (char *) "self",(char *) "x", NULL
18254 };
18255
18256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18258 if (!SWIG_IsOK(res1)) {
18259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18260 }
18261 arg1 = reinterpret_cast< wxGrid * >(argp1);
18262 ecode2 = SWIG_AsVal_int(obj1, &val2);
18263 if (!SWIG_IsOK(ecode2)) {
18264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18265 }
18266 arg2 = static_cast< int >(val2);
18267 {
18268 PyThreadState* __tstate = wxPyBeginAllowThreads();
18269 (arg1)->SetScrollLineX(arg2);
18270 wxPyEndAllowThreads(__tstate);
18271 if (PyErr_Occurred()) SWIG_fail;
18272 }
18273 resultobj = SWIG_Py_Void();
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj = 0;
18282 wxGrid *arg1 = (wxGrid *) 0 ;
18283 int arg2 ;
18284 void *argp1 = 0 ;
18285 int res1 = 0 ;
18286 int val2 ;
18287 int ecode2 = 0 ;
18288 PyObject * obj0 = 0 ;
18289 PyObject * obj1 = 0 ;
18290 char * kwnames[] = {
18291 (char *) "self",(char *) "y", NULL
18292 };
18293
18294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18296 if (!SWIG_IsOK(res1)) {
18297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18298 }
18299 arg1 = reinterpret_cast< wxGrid * >(argp1);
18300 ecode2 = SWIG_AsVal_int(obj1, &val2);
18301 if (!SWIG_IsOK(ecode2)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18303 }
18304 arg2 = static_cast< int >(val2);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 (arg1)->SetScrollLineY(arg2);
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = SWIG_Py_Void();
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18319 PyObject *resultobj = 0;
18320 wxGrid *arg1 = (wxGrid *) 0 ;
18321 int result;
18322 void *argp1 = 0 ;
18323 int res1 = 0 ;
18324 PyObject *swig_obj[1] ;
18325
18326 if (!args) SWIG_fail;
18327 swig_obj[0] = args;
18328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18329 if (!SWIG_IsOK(res1)) {
18330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18331 }
18332 arg1 = reinterpret_cast< wxGrid * >(argp1);
18333 {
18334 PyThreadState* __tstate = wxPyBeginAllowThreads();
18335 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 resultobj = SWIG_From_int(static_cast< int >(result));
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18347 PyObject *resultobj = 0;
18348 wxGrid *arg1 = (wxGrid *) 0 ;
18349 int result;
18350 void *argp1 = 0 ;
18351 int res1 = 0 ;
18352 PyObject *swig_obj[1] ;
18353
18354 if (!args) SWIG_fail;
18355 swig_obj[0] = args;
18356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18357 if (!SWIG_IsOK(res1)) {
18358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18359 }
18360 arg1 = reinterpret_cast< wxGrid * >(argp1);
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18364 wxPyEndAllowThreads(__tstate);
18365 if (PyErr_Occurred()) SWIG_fail;
18366 }
18367 resultobj = SWIG_From_int(static_cast< int >(result));
18368 return resultobj;
18369 fail:
18370 return NULL;
18371 }
18372
18373
18374 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18375 PyObject *resultobj = 0;
18376 wxGrid *arg1 = (wxGrid *) 0 ;
18377 int arg2 ;
18378 int result;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 int val2 ;
18382 int ecode2 = 0 ;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 char * kwnames[] = {
18386 (char *) "self",(char *) "x", NULL
18387 };
18388
18389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18391 if (!SWIG_IsOK(res1)) {
18392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18393 }
18394 arg1 = reinterpret_cast< wxGrid * >(argp1);
18395 ecode2 = SWIG_AsVal_int(obj1, &val2);
18396 if (!SWIG_IsOK(ecode2)) {
18397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18398 }
18399 arg2 = static_cast< int >(val2);
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_From_int(static_cast< int >(result));
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj = 0;
18415 wxGrid *arg1 = (wxGrid *) 0 ;
18416 int arg2 ;
18417 int result;
18418 void *argp1 = 0 ;
18419 int res1 = 0 ;
18420 int val2 ;
18421 int ecode2 = 0 ;
18422 PyObject * obj0 = 0 ;
18423 PyObject * obj1 = 0 ;
18424 char * kwnames[] = {
18425 (char *) "self",(char *) "y", NULL
18426 };
18427
18428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18430 if (!SWIG_IsOK(res1)) {
18431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18432 }
18433 arg1 = reinterpret_cast< wxGrid * >(argp1);
18434 ecode2 = SWIG_AsVal_int(obj1, &val2);
18435 if (!SWIG_IsOK(ecode2)) {
18436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18437 }
18438 arg2 = static_cast< int >(val2);
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18442 wxPyEndAllowThreads(__tstate);
18443 if (PyErr_Occurred()) SWIG_fail;
18444 }
18445 resultobj = SWIG_From_int(static_cast< int >(result));
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj = 0;
18454 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18455 SwigValueWrapper<wxVisualAttributes > result;
18456 int val1 ;
18457 int ecode1 = 0 ;
18458 PyObject * obj0 = 0 ;
18459 char * kwnames[] = {
18460 (char *) "variant", NULL
18461 };
18462
18463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18464 if (obj0) {
18465 ecode1 = SWIG_AsVal_int(obj0, &val1);
18466 if (!SWIG_IsOK(ecode1)) {
18467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18468 }
18469 arg1 = static_cast< wxWindowVariant >(val1);
18470 }
18471 {
18472 if (!wxPyCheckForApp()) SWIG_fail;
18473 PyThreadState* __tstate = wxPyBeginAllowThreads();
18474 result = wxGrid::GetClassDefaultAttributes(arg1);
18475 wxPyEndAllowThreads(__tstate);
18476 if (PyErr_Occurred()) SWIG_fail;
18477 }
18478 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18486 PyObject *obj;
18487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18488 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18489 return SWIG_Py_Void();
18490 }
18491
18492 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18493 return SWIG_Python_InitShadowInstance(args);
18494 }
18495
18496 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj = 0;
18498 int arg1 ;
18499 wxEventType arg2 ;
18500 wxGrid *arg3 = (wxGrid *) 0 ;
18501 int arg4 = (int) -1 ;
18502 int arg5 = (int) -1 ;
18503 int arg6 = (int) -1 ;
18504 int arg7 = (int) -1 ;
18505 bool arg8 = (bool) true ;
18506 bool arg9 = (bool) false ;
18507 bool arg10 = (bool) false ;
18508 bool arg11 = (bool) false ;
18509 bool arg12 = (bool) false ;
18510 wxGridEvent *result = 0 ;
18511 int val1 ;
18512 int ecode1 = 0 ;
18513 int val2 ;
18514 int ecode2 = 0 ;
18515 void *argp3 = 0 ;
18516 int res3 = 0 ;
18517 int val4 ;
18518 int ecode4 = 0 ;
18519 int val5 ;
18520 int ecode5 = 0 ;
18521 int val6 ;
18522 int ecode6 = 0 ;
18523 int val7 ;
18524 int ecode7 = 0 ;
18525 bool val8 ;
18526 int ecode8 = 0 ;
18527 bool val9 ;
18528 int ecode9 = 0 ;
18529 bool val10 ;
18530 int ecode10 = 0 ;
18531 bool val11 ;
18532 int ecode11 = 0 ;
18533 bool val12 ;
18534 int ecode12 = 0 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 PyObject * obj2 = 0 ;
18538 PyObject * obj3 = 0 ;
18539 PyObject * obj4 = 0 ;
18540 PyObject * obj5 = 0 ;
18541 PyObject * obj6 = 0 ;
18542 PyObject * obj7 = 0 ;
18543 PyObject * obj8 = 0 ;
18544 PyObject * obj9 = 0 ;
18545 PyObject * obj10 = 0 ;
18546 PyObject * obj11 = 0 ;
18547 char * kwnames[] = {
18548 (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
18549 };
18550
18551 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;
18552 ecode1 = SWIG_AsVal_int(obj0, &val1);
18553 if (!SWIG_IsOK(ecode1)) {
18554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18555 }
18556 arg1 = static_cast< int >(val1);
18557 ecode2 = SWIG_AsVal_int(obj1, &val2);
18558 if (!SWIG_IsOK(ecode2)) {
18559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18560 }
18561 arg2 = static_cast< wxEventType >(val2);
18562 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18563 if (!SWIG_IsOK(res3)) {
18564 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18565 }
18566 arg3 = reinterpret_cast< wxGrid * >(argp3);
18567 if (obj3) {
18568 ecode4 = SWIG_AsVal_int(obj3, &val4);
18569 if (!SWIG_IsOK(ecode4)) {
18570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18571 }
18572 arg4 = static_cast< int >(val4);
18573 }
18574 if (obj4) {
18575 ecode5 = SWIG_AsVal_int(obj4, &val5);
18576 if (!SWIG_IsOK(ecode5)) {
18577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18578 }
18579 arg5 = static_cast< int >(val5);
18580 }
18581 if (obj5) {
18582 ecode6 = SWIG_AsVal_int(obj5, &val6);
18583 if (!SWIG_IsOK(ecode6)) {
18584 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18585 }
18586 arg6 = static_cast< int >(val6);
18587 }
18588 if (obj6) {
18589 ecode7 = SWIG_AsVal_int(obj6, &val7);
18590 if (!SWIG_IsOK(ecode7)) {
18591 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18592 }
18593 arg7 = static_cast< int >(val7);
18594 }
18595 if (obj7) {
18596 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18597 if (!SWIG_IsOK(ecode8)) {
18598 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18599 }
18600 arg8 = static_cast< bool >(val8);
18601 }
18602 if (obj8) {
18603 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18604 if (!SWIG_IsOK(ecode9)) {
18605 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18606 }
18607 arg9 = static_cast< bool >(val9);
18608 }
18609 if (obj9) {
18610 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18611 if (!SWIG_IsOK(ecode10)) {
18612 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18613 }
18614 arg10 = static_cast< bool >(val10);
18615 }
18616 if (obj10) {
18617 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18618 if (!SWIG_IsOK(ecode11)) {
18619 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18620 }
18621 arg11 = static_cast< bool >(val11);
18622 }
18623 if (obj11) {
18624 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18625 if (!SWIG_IsOK(ecode12)) {
18626 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18627 }
18628 arg12 = static_cast< bool >(val12);
18629 }
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18646 int result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18656 }
18657 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)(arg1)->GetRow();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_From_int(static_cast< int >(result));
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18672 PyObject *resultobj = 0;
18673 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18674 int result;
18675 void *argp1 = 0 ;
18676 int res1 = 0 ;
18677 PyObject *swig_obj[1] ;
18678
18679 if (!args) SWIG_fail;
18680 swig_obj[0] = args;
18681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18682 if (!SWIG_IsOK(res1)) {
18683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18684 }
18685 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18686 {
18687 PyThreadState* __tstate = wxPyBeginAllowThreads();
18688 result = (int)(arg1)->GetCol();
18689 wxPyEndAllowThreads(__tstate);
18690 if (PyErr_Occurred()) SWIG_fail;
18691 }
18692 resultobj = SWIG_From_int(static_cast< int >(result));
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18700 PyObject *resultobj = 0;
18701 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18702 wxPoint result;
18703 void *argp1 = 0 ;
18704 int res1 = 0 ;
18705 PyObject *swig_obj[1] ;
18706
18707 if (!args) SWIG_fail;
18708 swig_obj[0] = args;
18709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18710 if (!SWIG_IsOK(res1)) {
18711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18712 }
18713 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18714 {
18715 PyThreadState* __tstate = wxPyBeginAllowThreads();
18716 result = (arg1)->GetPosition();
18717 wxPyEndAllowThreads(__tstate);
18718 if (PyErr_Occurred()) SWIG_fail;
18719 }
18720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18721 return resultobj;
18722 fail:
18723 return NULL;
18724 }
18725
18726
18727 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18728 PyObject *resultobj = 0;
18729 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18730 bool result;
18731 void *argp1 = 0 ;
18732 int res1 = 0 ;
18733 PyObject *swig_obj[1] ;
18734
18735 if (!args) SWIG_fail;
18736 swig_obj[0] = args;
18737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18740 }
18741 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 result = (bool)(arg1)->Selecting();
18745 wxPyEndAllowThreads(__tstate);
18746 if (PyErr_Occurred()) SWIG_fail;
18747 }
18748 {
18749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18750 }
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18758 PyObject *resultobj = 0;
18759 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18760 bool result;
18761 void *argp1 = 0 ;
18762 int res1 = 0 ;
18763 PyObject *swig_obj[1] ;
18764
18765 if (!args) SWIG_fail;
18766 swig_obj[0] = args;
18767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18768 if (!SWIG_IsOK(res1)) {
18769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18770 }
18771 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18772 {
18773 PyThreadState* __tstate = wxPyBeginAllowThreads();
18774 result = (bool)(arg1)->ControlDown();
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 {
18779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18780 }
18781 return resultobj;
18782 fail:
18783 return NULL;
18784 }
18785
18786
18787 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18788 PyObject *resultobj = 0;
18789 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18790 bool result;
18791 void *argp1 = 0 ;
18792 int res1 = 0 ;
18793 PyObject *swig_obj[1] ;
18794
18795 if (!args) SWIG_fail;
18796 swig_obj[0] = args;
18797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18798 if (!SWIG_IsOK(res1)) {
18799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18800 }
18801 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18802 {
18803 PyThreadState* __tstate = wxPyBeginAllowThreads();
18804 result = (bool)(arg1)->MetaDown();
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 {
18809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18810 }
18811 return resultobj;
18812 fail:
18813 return NULL;
18814 }
18815
18816
18817 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18818 PyObject *resultobj = 0;
18819 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18820 bool result;
18821 void *argp1 = 0 ;
18822 int res1 = 0 ;
18823 PyObject *swig_obj[1] ;
18824
18825 if (!args) SWIG_fail;
18826 swig_obj[0] = args;
18827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18830 }
18831 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 result = (bool)(arg1)->ShiftDown();
18835 wxPyEndAllowThreads(__tstate);
18836 if (PyErr_Occurred()) SWIG_fail;
18837 }
18838 {
18839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18840 }
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18848 PyObject *resultobj = 0;
18849 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18850 bool result;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 PyObject *swig_obj[1] ;
18854
18855 if (!args) SWIG_fail;
18856 swig_obj[0] = args;
18857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18860 }
18861 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 result = (bool)(arg1)->AltDown();
18865 wxPyEndAllowThreads(__tstate);
18866 if (PyErr_Occurred()) SWIG_fail;
18867 }
18868 {
18869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18870 }
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878 PyObject *resultobj = 0;
18879 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18880 bool result;
18881 void *argp1 = 0 ;
18882 int res1 = 0 ;
18883 PyObject *swig_obj[1] ;
18884
18885 if (!args) SWIG_fail;
18886 swig_obj[0] = args;
18887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18890 }
18891 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 result = (bool)(arg1)->CmdDown();
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 {
18899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18900 }
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *obj;
18909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18910 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
18911 return SWIG_Py_Void();
18912 }
18913
18914 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18915 return SWIG_Python_InitShadowInstance(args);
18916 }
18917
18918 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18919 PyObject *resultobj = 0;
18920 int arg1 ;
18921 wxEventType arg2 ;
18922 wxGrid *arg3 = (wxGrid *) 0 ;
18923 int arg4 = (int) -1 ;
18924 int arg5 = (int) -1 ;
18925 int arg6 = (int) -1 ;
18926 bool arg7 = (bool) false ;
18927 bool arg8 = (bool) false ;
18928 bool arg9 = (bool) false ;
18929 bool arg10 = (bool) false ;
18930 wxGridSizeEvent *result = 0 ;
18931 int val1 ;
18932 int ecode1 = 0 ;
18933 int val2 ;
18934 int ecode2 = 0 ;
18935 void *argp3 = 0 ;
18936 int res3 = 0 ;
18937 int val4 ;
18938 int ecode4 = 0 ;
18939 int val5 ;
18940 int ecode5 = 0 ;
18941 int val6 ;
18942 int ecode6 = 0 ;
18943 bool val7 ;
18944 int ecode7 = 0 ;
18945 bool val8 ;
18946 int ecode8 = 0 ;
18947 bool val9 ;
18948 int ecode9 = 0 ;
18949 bool val10 ;
18950 int ecode10 = 0 ;
18951 PyObject * obj0 = 0 ;
18952 PyObject * obj1 = 0 ;
18953 PyObject * obj2 = 0 ;
18954 PyObject * obj3 = 0 ;
18955 PyObject * obj4 = 0 ;
18956 PyObject * obj5 = 0 ;
18957 PyObject * obj6 = 0 ;
18958 PyObject * obj7 = 0 ;
18959 PyObject * obj8 = 0 ;
18960 PyObject * obj9 = 0 ;
18961 char * kwnames[] = {
18962 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
18963 };
18964
18965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
18966 ecode1 = SWIG_AsVal_int(obj0, &val1);
18967 if (!SWIG_IsOK(ecode1)) {
18968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
18969 }
18970 arg1 = static_cast< int >(val1);
18971 ecode2 = SWIG_AsVal_int(obj1, &val2);
18972 if (!SWIG_IsOK(ecode2)) {
18973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18974 }
18975 arg2 = static_cast< wxEventType >(val2);
18976 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18977 if (!SWIG_IsOK(res3)) {
18978 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18979 }
18980 arg3 = reinterpret_cast< wxGrid * >(argp3);
18981 if (obj3) {
18982 ecode4 = SWIG_AsVal_int(obj3, &val4);
18983 if (!SWIG_IsOK(ecode4)) {
18984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
18985 }
18986 arg4 = static_cast< int >(val4);
18987 }
18988 if (obj4) {
18989 ecode5 = SWIG_AsVal_int(obj4, &val5);
18990 if (!SWIG_IsOK(ecode5)) {
18991 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
18992 }
18993 arg5 = static_cast< int >(val5);
18994 }
18995 if (obj5) {
18996 ecode6 = SWIG_AsVal_int(obj5, &val6);
18997 if (!SWIG_IsOK(ecode6)) {
18998 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
18999 }
19000 arg6 = static_cast< int >(val6);
19001 }
19002 if (obj6) {
19003 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19004 if (!SWIG_IsOK(ecode7)) {
19005 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19006 }
19007 arg7 = static_cast< bool >(val7);
19008 }
19009 if (obj7) {
19010 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19011 if (!SWIG_IsOK(ecode8)) {
19012 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19013 }
19014 arg8 = static_cast< bool >(val8);
19015 }
19016 if (obj8) {
19017 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19018 if (!SWIG_IsOK(ecode9)) {
19019 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19020 }
19021 arg9 = static_cast< bool >(val9);
19022 }
19023 if (obj9) {
19024 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19025 if (!SWIG_IsOK(ecode10)) {
19026 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19027 }
19028 arg10 = static_cast< bool >(val10);
19029 }
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19037 return resultobj;
19038 fail:
19039 return NULL;
19040 }
19041
19042
19043 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19044 PyObject *resultobj = 0;
19045 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19046 int result;
19047 void *argp1 = 0 ;
19048 int res1 = 0 ;
19049 PyObject *swig_obj[1] ;
19050
19051 if (!args) SWIG_fail;
19052 swig_obj[0] = args;
19053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19054 if (!SWIG_IsOK(res1)) {
19055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19056 }
19057 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 result = (int)(arg1)->GetRowOrCol();
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_From_int(static_cast< int >(result));
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19072 PyObject *resultobj = 0;
19073 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19074 wxPoint result;
19075 void *argp1 = 0 ;
19076 int res1 = 0 ;
19077 PyObject *swig_obj[1] ;
19078
19079 if (!args) SWIG_fail;
19080 swig_obj[0] = args;
19081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19082 if (!SWIG_IsOK(res1)) {
19083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19084 }
19085 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19086 {
19087 PyThreadState* __tstate = wxPyBeginAllowThreads();
19088 result = (arg1)->GetPosition();
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19100 PyObject *resultobj = 0;
19101 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19102 bool result;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 PyObject *swig_obj[1] ;
19106
19107 if (!args) SWIG_fail;
19108 swig_obj[0] = args;
19109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19112 }
19113 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (bool)(arg1)->ControlDown();
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 {
19121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19122 }
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19130 PyObject *resultobj = 0;
19131 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19132 bool result;
19133 void *argp1 = 0 ;
19134 int res1 = 0 ;
19135 PyObject *swig_obj[1] ;
19136
19137 if (!args) SWIG_fail;
19138 swig_obj[0] = args;
19139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19140 if (!SWIG_IsOK(res1)) {
19141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19142 }
19143 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19144 {
19145 PyThreadState* __tstate = wxPyBeginAllowThreads();
19146 result = (bool)(arg1)->MetaDown();
19147 wxPyEndAllowThreads(__tstate);
19148 if (PyErr_Occurred()) SWIG_fail;
19149 }
19150 {
19151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19152 }
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19162 bool result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19172 }
19173 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (bool)(arg1)->ShiftDown();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 {
19181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19190 PyObject *resultobj = 0;
19191 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19192 bool result;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 PyObject *swig_obj[1] ;
19196
19197 if (!args) SWIG_fail;
19198 swig_obj[0] = args;
19199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19200 if (!SWIG_IsOK(res1)) {
19201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19202 }
19203 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 result = (bool)(arg1)->AltDown();
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 {
19211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19220 PyObject *resultobj = 0;
19221 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19222 bool result;
19223 void *argp1 = 0 ;
19224 int res1 = 0 ;
19225 PyObject *swig_obj[1] ;
19226
19227 if (!args) SWIG_fail;
19228 swig_obj[0] = args;
19229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19230 if (!SWIG_IsOK(res1)) {
19231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19232 }
19233 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (bool)(arg1)->CmdDown();
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19250 PyObject *obj;
19251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19252 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19253 return SWIG_Py_Void();
19254 }
19255
19256 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257 return SWIG_Python_InitShadowInstance(args);
19258 }
19259
19260 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19261 PyObject *resultobj = 0;
19262 int arg1 ;
19263 wxEventType arg2 ;
19264 wxGrid *arg3 = (wxGrid *) 0 ;
19265 wxGridCellCoords *arg4 = 0 ;
19266 wxGridCellCoords *arg5 = 0 ;
19267 bool arg6 = (bool) true ;
19268 bool arg7 = (bool) false ;
19269 bool arg8 = (bool) false ;
19270 bool arg9 = (bool) false ;
19271 bool arg10 = (bool) false ;
19272 wxGridRangeSelectEvent *result = 0 ;
19273 int val1 ;
19274 int ecode1 = 0 ;
19275 int val2 ;
19276 int ecode2 = 0 ;
19277 void *argp3 = 0 ;
19278 int res3 = 0 ;
19279 wxGridCellCoords temp4 ;
19280 wxGridCellCoords temp5 ;
19281 bool val6 ;
19282 int ecode6 = 0 ;
19283 bool val7 ;
19284 int ecode7 = 0 ;
19285 bool val8 ;
19286 int ecode8 = 0 ;
19287 bool val9 ;
19288 int ecode9 = 0 ;
19289 bool val10 ;
19290 int ecode10 = 0 ;
19291 PyObject * obj0 = 0 ;
19292 PyObject * obj1 = 0 ;
19293 PyObject * obj2 = 0 ;
19294 PyObject * obj3 = 0 ;
19295 PyObject * obj4 = 0 ;
19296 PyObject * obj5 = 0 ;
19297 PyObject * obj6 = 0 ;
19298 PyObject * obj7 = 0 ;
19299 PyObject * obj8 = 0 ;
19300 PyObject * obj9 = 0 ;
19301 char * kwnames[] = {
19302 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19303 };
19304
19305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19306 ecode1 = SWIG_AsVal_int(obj0, &val1);
19307 if (!SWIG_IsOK(ecode1)) {
19308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19309 }
19310 arg1 = static_cast< int >(val1);
19311 ecode2 = SWIG_AsVal_int(obj1, &val2);
19312 if (!SWIG_IsOK(ecode2)) {
19313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19314 }
19315 arg2 = static_cast< wxEventType >(val2);
19316 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19317 if (!SWIG_IsOK(res3)) {
19318 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19319 }
19320 arg3 = reinterpret_cast< wxGrid * >(argp3);
19321 {
19322 arg4 = &temp4;
19323 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19324 }
19325 {
19326 arg5 = &temp5;
19327 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19328 }
19329 if (obj5) {
19330 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19331 if (!SWIG_IsOK(ecode6)) {
19332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19333 }
19334 arg6 = static_cast< bool >(val6);
19335 }
19336 if (obj6) {
19337 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19338 if (!SWIG_IsOK(ecode7)) {
19339 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19340 }
19341 arg7 = static_cast< bool >(val7);
19342 }
19343 if (obj7) {
19344 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19345 if (!SWIG_IsOK(ecode8)) {
19346 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19347 }
19348 arg8 = static_cast< bool >(val8);
19349 }
19350 if (obj8) {
19351 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19352 if (!SWIG_IsOK(ecode9)) {
19353 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19354 }
19355 arg9 = static_cast< bool >(val9);
19356 }
19357 if (obj9) {
19358 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19359 if (!SWIG_IsOK(ecode10)) {
19360 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19361 }
19362 arg10 = static_cast< bool >(val10);
19363 }
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19371 return resultobj;
19372 fail:
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19378 PyObject *resultobj = 0;
19379 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19380 wxGridCellCoords result;
19381 void *argp1 = 0 ;
19382 int res1 = 0 ;
19383 PyObject *swig_obj[1] ;
19384
19385 if (!args) SWIG_fail;
19386 swig_obj[0] = args;
19387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19388 if (!SWIG_IsOK(res1)) {
19389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19390 }
19391 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19392 {
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 result = (arg1)->GetTopLeftCoords();
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19399 return resultobj;
19400 fail:
19401 return NULL;
19402 }
19403
19404
19405 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19406 PyObject *resultobj = 0;
19407 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19408 wxGridCellCoords result;
19409 void *argp1 = 0 ;
19410 int res1 = 0 ;
19411 PyObject *swig_obj[1] ;
19412
19413 if (!args) SWIG_fail;
19414 swig_obj[0] = args;
19415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19416 if (!SWIG_IsOK(res1)) {
19417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19418 }
19419 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19420 {
19421 PyThreadState* __tstate = wxPyBeginAllowThreads();
19422 result = (arg1)->GetBottomRightCoords();
19423 wxPyEndAllowThreads(__tstate);
19424 if (PyErr_Occurred()) SWIG_fail;
19425 }
19426 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19427 return resultobj;
19428 fail:
19429 return NULL;
19430 }
19431
19432
19433 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19434 PyObject *resultobj = 0;
19435 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19436 int result;
19437 void *argp1 = 0 ;
19438 int res1 = 0 ;
19439 PyObject *swig_obj[1] ;
19440
19441 if (!args) SWIG_fail;
19442 swig_obj[0] = args;
19443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19444 if (!SWIG_IsOK(res1)) {
19445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19446 }
19447 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (int)(arg1)->GetTopRow();
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 resultobj = SWIG_From_int(static_cast< int >(result));
19455 return resultobj;
19456 fail:
19457 return NULL;
19458 }
19459
19460
19461 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19462 PyObject *resultobj = 0;
19463 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19464 int result;
19465 void *argp1 = 0 ;
19466 int res1 = 0 ;
19467 PyObject *swig_obj[1] ;
19468
19469 if (!args) SWIG_fail;
19470 swig_obj[0] = args;
19471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19472 if (!SWIG_IsOK(res1)) {
19473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19474 }
19475 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 result = (int)(arg1)->GetBottomRow();
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_From_int(static_cast< int >(result));
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19492 int result;
19493 void *argp1 = 0 ;
19494 int res1 = 0 ;
19495 PyObject *swig_obj[1] ;
19496
19497 if (!args) SWIG_fail;
19498 swig_obj[0] = args;
19499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19500 if (!SWIG_IsOK(res1)) {
19501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19502 }
19503 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = (int)(arg1)->GetLeftCol();
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_From_int(static_cast< int >(result));
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19518 PyObject *resultobj = 0;
19519 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19520 int result;
19521 void *argp1 = 0 ;
19522 int res1 = 0 ;
19523 PyObject *swig_obj[1] ;
19524
19525 if (!args) SWIG_fail;
19526 swig_obj[0] = args;
19527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19530 }
19531 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19532 {
19533 PyThreadState* __tstate = wxPyBeginAllowThreads();
19534 result = (int)(arg1)->GetRightCol();
19535 wxPyEndAllowThreads(__tstate);
19536 if (PyErr_Occurred()) SWIG_fail;
19537 }
19538 resultobj = SWIG_From_int(static_cast< int >(result));
19539 return resultobj;
19540 fail:
19541 return NULL;
19542 }
19543
19544
19545 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19546 PyObject *resultobj = 0;
19547 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19548 bool result;
19549 void *argp1 = 0 ;
19550 int res1 = 0 ;
19551 PyObject *swig_obj[1] ;
19552
19553 if (!args) SWIG_fail;
19554 swig_obj[0] = args;
19555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19556 if (!SWIG_IsOK(res1)) {
19557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19558 }
19559 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19560 {
19561 PyThreadState* __tstate = wxPyBeginAllowThreads();
19562 result = (bool)(arg1)->Selecting();
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 {
19567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19568 }
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19576 PyObject *resultobj = 0;
19577 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19578 bool result;
19579 void *argp1 = 0 ;
19580 int res1 = 0 ;
19581 PyObject *swig_obj[1] ;
19582
19583 if (!args) SWIG_fail;
19584 swig_obj[0] = args;
19585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19586 if (!SWIG_IsOK(res1)) {
19587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19588 }
19589 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 result = (bool)(arg1)->ControlDown();
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 {
19597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19598 }
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19606 PyObject *resultobj = 0;
19607 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19608 bool result;
19609 void *argp1 = 0 ;
19610 int res1 = 0 ;
19611 PyObject *swig_obj[1] ;
19612
19613 if (!args) SWIG_fail;
19614 swig_obj[0] = args;
19615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19618 }
19619 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 result = (bool)(arg1)->MetaDown();
19623 wxPyEndAllowThreads(__tstate);
19624 if (PyErr_Occurred()) SWIG_fail;
19625 }
19626 {
19627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19628 }
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19636 PyObject *resultobj = 0;
19637 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19638 bool result;
19639 void *argp1 = 0 ;
19640 int res1 = 0 ;
19641 PyObject *swig_obj[1] ;
19642
19643 if (!args) SWIG_fail;
19644 swig_obj[0] = args;
19645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19646 if (!SWIG_IsOK(res1)) {
19647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19648 }
19649 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = (bool)(arg1)->ShiftDown();
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 {
19657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19658 }
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19666 PyObject *resultobj = 0;
19667 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19668 bool result;
19669 void *argp1 = 0 ;
19670 int res1 = 0 ;
19671 PyObject *swig_obj[1] ;
19672
19673 if (!args) SWIG_fail;
19674 swig_obj[0] = args;
19675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19676 if (!SWIG_IsOK(res1)) {
19677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19678 }
19679 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = (bool)(arg1)->AltDown();
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 {
19687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19688 }
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19696 PyObject *resultobj = 0;
19697 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19698 bool result;
19699 void *argp1 = 0 ;
19700 int res1 = 0 ;
19701 PyObject *swig_obj[1] ;
19702
19703 if (!args) SWIG_fail;
19704 swig_obj[0] = args;
19705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19706 if (!SWIG_IsOK(res1)) {
19707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19708 }
19709 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = (bool)(arg1)->CmdDown();
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 {
19717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19718 }
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19726 PyObject *obj;
19727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19728 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19729 return SWIG_Py_Void();
19730 }
19731
19732 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 return SWIG_Python_InitShadowInstance(args);
19734 }
19735
19736 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj = 0;
19738 int arg1 ;
19739 wxEventType arg2 ;
19740 wxObject *arg3 = (wxObject *) 0 ;
19741 int arg4 ;
19742 int arg5 ;
19743 wxControl *arg6 = (wxControl *) 0 ;
19744 wxGridEditorCreatedEvent *result = 0 ;
19745 int val1 ;
19746 int ecode1 = 0 ;
19747 int val2 ;
19748 int ecode2 = 0 ;
19749 void *argp3 = 0 ;
19750 int res3 = 0 ;
19751 int val4 ;
19752 int ecode4 = 0 ;
19753 int val5 ;
19754 int ecode5 = 0 ;
19755 void *argp6 = 0 ;
19756 int res6 = 0 ;
19757 PyObject * obj0 = 0 ;
19758 PyObject * obj1 = 0 ;
19759 PyObject * obj2 = 0 ;
19760 PyObject * obj3 = 0 ;
19761 PyObject * obj4 = 0 ;
19762 PyObject * obj5 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19768 ecode1 = SWIG_AsVal_int(obj0, &val1);
19769 if (!SWIG_IsOK(ecode1)) {
19770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
19771 }
19772 arg1 = static_cast< int >(val1);
19773 ecode2 = SWIG_AsVal_int(obj1, &val2);
19774 if (!SWIG_IsOK(ecode2)) {
19775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19776 }
19777 arg2 = static_cast< wxEventType >(val2);
19778 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
19779 if (!SWIG_IsOK(res3)) {
19780 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
19781 }
19782 arg3 = reinterpret_cast< wxObject * >(argp3);
19783 ecode4 = SWIG_AsVal_int(obj3, &val4);
19784 if (!SWIG_IsOK(ecode4)) {
19785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
19786 }
19787 arg4 = static_cast< int >(val4);
19788 ecode5 = SWIG_AsVal_int(obj4, &val5);
19789 if (!SWIG_IsOK(ecode5)) {
19790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
19791 }
19792 arg5 = static_cast< int >(val5);
19793 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
19794 if (!SWIG_IsOK(res6)) {
19795 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
19796 }
19797 arg6 = reinterpret_cast< wxControl * >(argp6);
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
19805 return resultobj;
19806 fail:
19807 return NULL;
19808 }
19809
19810
19811 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19812 PyObject *resultobj = 0;
19813 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19814 int result;
19815 void *argp1 = 0 ;
19816 int res1 = 0 ;
19817 PyObject *swig_obj[1] ;
19818
19819 if (!args) SWIG_fail;
19820 swig_obj[0] = args;
19821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19824 }
19825 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 result = (int)(arg1)->GetRow();
19829 wxPyEndAllowThreads(__tstate);
19830 if (PyErr_Occurred()) SWIG_fail;
19831 }
19832 resultobj = SWIG_From_int(static_cast< int >(result));
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19840 PyObject *resultobj = 0;
19841 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19842 int result;
19843 void *argp1 = 0 ;
19844 int res1 = 0 ;
19845 PyObject *swig_obj[1] ;
19846
19847 if (!args) SWIG_fail;
19848 swig_obj[0] = args;
19849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19850 if (!SWIG_IsOK(res1)) {
19851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19852 }
19853 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 result = (int)(arg1)->GetCol();
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 resultobj = SWIG_From_int(static_cast< int >(result));
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 PyObject *resultobj = 0;
19869 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19870 wxControl *result = 0 ;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 PyObject *swig_obj[1] ;
19874
19875 if (!args) SWIG_fail;
19876 swig_obj[0] = args;
19877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19878 if (!SWIG_IsOK(res1)) {
19879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19880 }
19881 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (wxControl *)(arg1)->GetControl();
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 {
19889 resultobj = wxPyMake_wxObject(result, 0);
19890 }
19891 return resultobj;
19892 fail:
19893 return NULL;
19894 }
19895
19896
19897 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19898 PyObject *resultobj = 0;
19899 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19900 int arg2 ;
19901 void *argp1 = 0 ;
19902 int res1 = 0 ;
19903 int val2 ;
19904 int ecode2 = 0 ;
19905 PyObject * obj0 = 0 ;
19906 PyObject * obj1 = 0 ;
19907 char * kwnames[] = {
19908 (char *) "self",(char *) "row", NULL
19909 };
19910
19911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
19912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19913 if (!SWIG_IsOK(res1)) {
19914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19915 }
19916 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19917 ecode2 = SWIG_AsVal_int(obj1, &val2);
19918 if (!SWIG_IsOK(ecode2)) {
19919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
19920 }
19921 arg2 = static_cast< int >(val2);
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 (arg1)->SetRow(arg2);
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 resultobj = SWIG_Py_Void();
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = 0;
19937 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19938 int arg2 ;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 int val2 ;
19942 int ecode2 = 0 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char * kwnames[] = {
19946 (char *) "self",(char *) "col", NULL
19947 };
19948
19949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
19950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19953 }
19954 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19955 ecode2 = SWIG_AsVal_int(obj1, &val2);
19956 if (!SWIG_IsOK(ecode2)) {
19957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
19958 }
19959 arg2 = static_cast< int >(val2);
19960 {
19961 PyThreadState* __tstate = wxPyBeginAllowThreads();
19962 (arg1)->SetCol(arg2);
19963 wxPyEndAllowThreads(__tstate);
19964 if (PyErr_Occurred()) SWIG_fail;
19965 }
19966 resultobj = SWIG_Py_Void();
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj = 0;
19975 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19976 wxControl *arg2 = (wxControl *) 0 ;
19977 void *argp1 = 0 ;
19978 int res1 = 0 ;
19979 void *argp2 = 0 ;
19980 int res2 = 0 ;
19981 PyObject * obj0 = 0 ;
19982 PyObject * obj1 = 0 ;
19983 char * kwnames[] = {
19984 (char *) "self",(char *) "ctrl", NULL
19985 };
19986
19987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
19988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19989 if (!SWIG_IsOK(res1)) {
19990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19991 }
19992 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
19994 if (!SWIG_IsOK(res2)) {
19995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
19996 }
19997 arg2 = reinterpret_cast< wxControl * >(argp2);
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 (arg1)->SetControl(arg2);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_Py_Void();
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012 PyObject *obj;
20013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20014 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20015 return SWIG_Py_Void();
20016 }
20017
20018 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20019 return SWIG_Python_InitShadowInstance(args);
20020 }
20021
20022 static PyMethodDef SwigMethods[] = {
20023 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20024 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20025 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20026 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20027 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20028 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20029 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20030 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20031 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20032 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20033 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20034 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20035 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20036 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20037 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20038 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20039 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20040 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20041 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20042 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20043 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20044 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20045 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20046 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20047 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20048 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20049 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20050 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20051 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20052 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20053 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20054 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20055 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20056 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20057 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20058 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20059 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20060 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20061 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20062 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20063 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20064 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20065 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20066 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20067 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20068 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20069 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20070 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20071 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20072 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20073 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20074 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20075 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20076 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20077 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20078 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20079 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20080 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20081 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20082 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20083 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20084 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20085 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20086 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20087 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20088 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20089 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20090 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20091 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20092 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20093 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20094 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20095 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20096 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20097 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20098 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20099 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20100 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20101 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20102 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20103 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20104 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20105 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20106 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20107 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20108 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20109 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20110 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20111 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20112 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20113 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20114 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20115 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20116 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20117 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20118 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20119 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20120 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20121 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20122 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20123 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20124 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20125 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20126 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20127 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20128 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20129 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20130 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20131 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20132 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20133 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20134 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20135 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20136 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20137 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20138 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20139 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20140 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20141 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20142 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20143 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20144 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20145 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20146 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20147 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20148 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20149 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20150 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20151 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20152 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20153 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20154 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20155 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20156 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20157 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20158 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20159 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20160 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20161 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20162 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20163 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20164 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20165 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20166 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20167 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20168 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20169 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20170 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20171 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20172 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20173 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20174 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20175 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20176 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20177 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20178 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20179 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20180 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20181 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20182 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20183 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20184 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20185 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20186 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20187 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20188 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20189 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20190 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20191 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20192 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20193 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20194 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20195 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20196 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20197 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20198 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20199 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20200 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20201 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20202 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20203 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20204 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20205 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20206 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20207 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20208 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20209 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20210 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20211 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20212 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20213 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20214 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20215 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20216 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20217 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20218 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20219 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20220 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20221 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20222 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20223 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20224 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20225 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20226 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20227 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20228 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20229 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20230 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20231 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20232 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20233 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20234 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20235 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20236 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20237 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20238 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20239 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20240 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20241 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20242 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20243 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20244 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20245 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20246 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20247 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20248 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20249 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20250 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20251 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20252 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20253 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20254 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20255 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20256 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20257 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20258 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20259 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20260 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20261 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20262 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20263 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20264 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20265 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20266 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20267 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20268 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20269 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20270 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20271 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20272 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20273 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20274 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20275 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20276 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20277 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20278 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20279 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20280 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20281 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20282 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20283 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20284 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20285 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20286 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20287 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20288 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20289 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20290 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20291 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20292 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20293 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20294 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20295 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20296 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20297 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20298 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20299 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20300 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20301 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20302 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20303 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20304 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20305 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20306 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20307 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20308 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20309 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20310 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20313 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20314 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20315 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20316 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20317 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20318 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20319 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20320 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20321 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20322 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20323 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20324 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20325 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20326 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20327 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20328 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20329 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20330 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20331 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20332 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20333 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20334 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20335 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20336 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20337 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20338 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20339 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20340 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20341 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20342 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20343 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20344 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20345 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20346 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20347 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20348 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20349 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20350 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20351 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20353 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20355 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20358 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20363 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20364 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20365 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20366 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20367 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20368 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20369 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20370 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20373 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20374 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20375 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20376 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20377 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20381 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20384 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20385 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20388 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20392 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20401 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20402 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20403 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20404 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20405 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20406 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20407 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20408 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20409 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20414 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20415 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20424 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20425 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20426 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20427 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20430 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20431 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20435 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20436 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20438 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20439 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20440 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20441 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20442 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20443 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20444 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20445 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20446 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20447 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20448 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20450 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20451 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20452 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20453 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20454 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20455 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20456 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20457 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20458 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20460 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20461 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20462 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20463 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20464 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20465 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20466 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20467 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20468 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20469 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20470 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20471 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20472 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20473 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20475 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20476 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20477 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20481 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20482 { NULL, NULL, 0, NULL }
20483 };
20484
20485
20486 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20487
20488 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20489 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20490 }
20491 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20492 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20493 }
20494 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20495 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20496 }
20497 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20498 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20499 }
20500 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20501 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20502 }
20503 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20504 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20505 }
20506 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20507 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20508 }
20509 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20510 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20511 }
20512 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20513 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20514 }
20515 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20516 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20517 }
20518 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20519 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20520 }
20521 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20522 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20523 }
20524 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20525 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20526 }
20527 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20528 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20529 }
20530 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20531 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20532 }
20533 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20534 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20535 }
20536 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20537 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20538 }
20539 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20540 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20541 }
20542 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20543 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20544 }
20545 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20546 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20547 }
20548 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20549 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20550 }
20551 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20552 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20553 }
20554 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20555 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20556 }
20557 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20558 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20559 }
20560 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20561 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20562 }
20563 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20564 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20565 }
20566 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20567 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20568 }
20569 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20570 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20571 }
20572 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20573 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20574 }
20575 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20576 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20577 }
20578 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20579 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20580 }
20581 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20582 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20583 }
20584 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20585 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20586 }
20587 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20588 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20589 }
20590 static void *_p_wxGridTo_p_wxPanel(void *x) {
20591 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20592 }
20593 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20594 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20595 }
20596 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20597 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20598 }
20599 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20600 return (void *)((wxPanel *) ((wxPyPanel *) x));
20601 }
20602 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20603 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20604 }
20605 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20606 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20607 }
20608 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20609 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20610 }
20611 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20612 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20613 }
20614 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20615 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20616 }
20617 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20618 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20619 }
20620 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20621 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20622 }
20623 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20624 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20625 }
20626 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20627 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20628 }
20629 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20630 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20631 }
20632 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20633 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20634 }
20635 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20636 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20637 }
20638 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20639 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20640 }
20641 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20642 return (void *)((wxWindow *) ((wxMenuBar *) x));
20643 }
20644 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20645 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20646 }
20647 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20648 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20649 }
20650 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20651 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20652 }
20653 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20654 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20655 }
20656 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20657 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20658 }
20659 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20660 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20661 }
20662 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20663 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20664 }
20665 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20666 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20667 }
20668 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20669 return (void *)((wxWindow *) ((wxPanel *) x));
20670 }
20671 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20672 return (void *)((wxWindow *) ((wxStatusBar *) x));
20673 }
20674 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20675 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20676 }
20677 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20678 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
20679 }
20680 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20681 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20682 }
20683 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20684 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20685 }
20686 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20687 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20688 }
20689 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20690 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20691 }
20692 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20693 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20694 }
20695 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20696 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20697 }
20698 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20699 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20700 }
20701 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20702 return (void *)((wxWindow *) ((wxSashWindow *) x));
20703 }
20704 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20705 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20706 }
20707 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20708 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20709 }
20710 static void *_p_wxControlTo_p_wxWindow(void *x) {
20711 return (void *)((wxWindow *) ((wxControl *) x));
20712 }
20713 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20714 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20715 }
20716 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20717 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20718 }
20719 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20720 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20721 }
20722 static void *_p_wxGridTo_p_wxWindow(void *x) {
20723 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20724 }
20725 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20726 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20727 }
20728 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20729 return (void *)((wxWindow *) ((wxPyWindow *) x));
20730 }
20731 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20732 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20733 }
20734 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20735 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20736 }
20737 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20738 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20739 }
20740 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20741 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20742 }
20743 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20744 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20745 }
20746 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20747 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20748 }
20749 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20750 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20751 }
20752 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20753 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20754 }
20755 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
20756 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
20757 }
20758 static void *_p_wxDialogTo_p_wxWindow(void *x) {
20759 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
20760 }
20761 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
20762 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
20763 }
20764 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
20765 return (void *)((wxControl *) ((wxControlWithItems *) x));
20766 }
20767 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
20768 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
20769 }
20770 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
20771 return (void *)((wxEvent *) ((wxMenuEvent *) x));
20772 }
20773 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
20774 return (void *)((wxEvent *) ((wxCloseEvent *) x));
20775 }
20776 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
20777 return (void *)((wxEvent *) ((wxMouseEvent *) x));
20778 }
20779 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
20780 return (void *)((wxEvent *) ((wxEraseEvent *) x));
20781 }
20782 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
20783 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
20784 }
20785 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
20786 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
20787 }
20788 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
20789 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
20790 }
20791 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
20792 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
20793 }
20794 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
20795 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
20796 }
20797 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
20798 return (void *)((wxEvent *) ((wxPyEvent *) x));
20799 }
20800 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
20801 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
20802 }
20803 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
20804 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
20805 }
20806 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
20807 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20808 }
20809 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
20810 return (void *)((wxEvent *) ((wxIdleEvent *) x));
20811 }
20812 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
20813 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
20814 }
20815 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
20816 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
20817 }
20818 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
20819 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
20820 }
20821 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
20822 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
20823 }
20824 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
20825 return (void *)((wxEvent *) ((wxActivateEvent *) x));
20826 }
20827 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
20828 return (void *)((wxEvent *) ((wxSizeEvent *) x));
20829 }
20830 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
20831 return (void *)((wxEvent *) ((wxMoveEvent *) x));
20832 }
20833 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
20834 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
20835 }
20836 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
20837 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
20838 }
20839 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
20840 return (void *)((wxEvent *) ((wxPaintEvent *) x));
20841 }
20842 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
20843 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
20844 }
20845 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
20846 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
20847 }
20848 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
20849 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
20850 }
20851 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
20852 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
20853 }
20854 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
20855 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20856 }
20857 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
20858 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
20859 }
20860 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
20861 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
20862 }
20863 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
20864 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
20865 }
20866 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
20867 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
20868 }
20869 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
20870 return (void *)((wxEvent *) ((wxFocusEvent *) x));
20871 }
20872 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
20873 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
20874 }
20875 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
20876 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
20877 }
20878 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
20879 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20880 }
20881 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
20882 return (void *)((wxEvent *) ((wxShowEvent *) x));
20883 }
20884 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
20885 return (void *)((wxEvent *) ((wxCommandEvent *) x));
20886 }
20887 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
20888 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
20889 }
20890 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
20891 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
20892 }
20893 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
20894 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
20895 }
20896 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
20897 return (void *)((wxEvent *) ((wxKeyEvent *) x));
20898 }
20899 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
20900 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
20901 }
20902 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
20903 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
20904 }
20905 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
20906 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
20907 }
20908 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
20909 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20910 }
20911 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
20912 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20913 }
20914 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
20915 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20916 }
20917 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
20918 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
20919 }
20920 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
20921 return (void *)((wxObject *) ((wxSizerItem *) x));
20922 }
20923 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
20924 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
20925 }
20926 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
20927 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
20928 }
20929 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
20930 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
20931 }
20932 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
20933 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
20934 }
20935 static void *_p_wxSizerTo_p_wxObject(void *x) {
20936 return (void *)((wxObject *) ((wxSizer *) x));
20937 }
20938 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
20939 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
20940 }
20941 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
20942 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
20943 }
20944 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
20945 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
20946 }
20947 static void *_p_wxEventTo_p_wxObject(void *x) {
20948 return (void *)((wxObject *) ((wxEvent *) x));
20949 }
20950 static void *_p_wxFontDataTo_p_wxObject(void *x) {
20951 return (void *)((wxObject *) ((wxFontData *) x));
20952 }
20953 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
20954 return (void *)((wxObject *) ((wxPrintData *) x));
20955 }
20956 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
20957 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
20958 }
20959 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
20960 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
20961 }
20962 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
20963 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
20964 }
20965 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
20966 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
20967 }
20968 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
20969 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
20970 }
20971 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
20972 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
20973 }
20974 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
20975 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
20976 }
20977 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
20978 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
20979 }
20980 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
20981 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
20982 }
20983 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
20984 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
20985 }
20986 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
20987 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
20988 }
20989 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
20990 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20991 }
20992 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
20993 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
20994 }
20995 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
20996 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20997 }
20998 static void *_p_wxGridEventTo_p_wxObject(void *x) {
20999 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21000 }
21001 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21002 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21003 }
21004 static void *_p_wxControlTo_p_wxObject(void *x) {
21005 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21006 }
21007 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21008 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21009 }
21010 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21011 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21012 }
21013 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21014 return (void *)((wxObject *) ((wxFSFile *) x));
21015 }
21016 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21017 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21018 }
21019 static void *_p_wxGridTo_p_wxObject(void *x) {
21020 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21021 }
21022 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21023 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21024 }
21025 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21026 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21027 }
21028 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21029 return (void *)((wxObject *) ((wxColourData *) x));
21030 }
21031 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21032 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21033 }
21034 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21035 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21036 }
21037 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21038 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21039 }
21040 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21041 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21042 }
21043 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21044 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21045 }
21046 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21047 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21048 }
21049 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21050 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21051 }
21052 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21053 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21054 }
21055 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21056 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21057 }
21058 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21059 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21060 }
21061 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21062 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21063 }
21064 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21065 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21066 }
21067 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21068 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21069 }
21070 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21071 return (void *)((wxObject *) ((wxPrinter *) x));
21072 }
21073 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21074 return (void *)((wxObject *) ((wxMenuItem *) x));
21075 }
21076 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21077 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21078 }
21079 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21081 }
21082 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21084 }
21085 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21087 }
21088 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21090 }
21091 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21093 }
21094 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21096 }
21097 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21099 }
21100 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21102 }
21103 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21105 }
21106 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21108 }
21109 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21111 }
21112 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21114 }
21115 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21117 }
21118 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21120 }
21121 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21123 }
21124 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21126 }
21127 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21129 }
21130 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21132 }
21133 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21135 }
21136 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) ((wxImageHandler *) x));
21138 }
21139 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21141 }
21142 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21144 }
21145 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) ((wxEvtHandler *) x));
21147 }
21148 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21150 }
21151 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21153 }
21154 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21156 }
21157 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21159 }
21160 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21162 }
21163 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21165 }
21166 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21168 }
21169 static void *_p_wxImageTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) ((wxImage *) x));
21171 }
21172 static void *_p_wxFrameTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21174 }
21175 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) ((wxPyPrintout *) x));
21177 }
21178 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21180 }
21181 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21183 }
21184 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21186 }
21187 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21189 }
21190 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21192 }
21193 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21195 }
21196 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21198 }
21199 static void *_p_wxWindowTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21201 }
21202 static void *_p_wxMenuTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21204 }
21205 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21207 }
21208 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21210 }
21211 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21213 }
21214 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21216 }
21217 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21219 }
21220 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21222 }
21223 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21225 }
21226 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21228 }
21229 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21231 }
21232 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21234 }
21235 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21237 }
21238 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21240 }
21241 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21243 }
21244 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21246 }
21247 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) ((wxPrintPreview *) x));
21249 }
21250 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21252 }
21253 static void *_p_wxPanelTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21255 }
21256 static void *_p_wxDialogTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21258 }
21259 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21261 }
21262 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21264 }
21265 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21267 }
21268 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21270 }
21271 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) ((wxPrintDialog *) x));
21273 }
21274 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) ((wxFileSystem *) x));
21276 }
21277 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21279 }
21280 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21282 }
21283 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21285 }
21286 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21288 }
21289 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21291 }
21292 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21294 }
21295 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) ((wxGridTableBase *) x));
21297 }
21298 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21300 }
21301 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21303 }
21304 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21306 }
21307 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21309 }
21310 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21312 }
21313 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21315 }
21316 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21318 }
21319 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21321 }
21322 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21324 }
21325 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21327 }
21328 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21330 }
21331 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21333 }
21334 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21336 }
21337 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21338 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21339 }
21340 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21341 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21342 }
21343 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21344 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21345 }
21346 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21347 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21348 }
21349 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21350 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21351 }
21352 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21353 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21354 }
21355 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21356 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21357 }
21358 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21359 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21360 }
21361 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21362 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21363 }
21364 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21365 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21366 }
21367 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21368 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21369 }
21370 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21371 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21372 }
21373 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21374 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21375 }
21376 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21377 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21378 }
21379 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21380 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21381 }
21382 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21383 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21384 }
21385 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21386 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21387 }
21388 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21389 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21390 }
21391 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21392 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21393 }
21394 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21395 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21396 }
21397 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21398 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21399 }
21400 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21401 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21402 }
21403 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21404 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21405 }
21406 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21407 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21408 }
21409 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21410 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21411 }
21412 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21413 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21414 }
21415 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21416 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21417 }
21418 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21419 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21420 }
21421 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21422 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21423 }
21424 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21425 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21426 }
21427 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21428 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21429 }
21430 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21431 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21432 }
21433 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21434 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21435 }
21436 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21437 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21438 }
21439 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21440 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21441 }
21442 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21443 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21444 }
21445 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21446 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21447 }
21448 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21449 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21450 }
21451 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21452 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21453 }
21454 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21455 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21456 }
21457 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21458 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21459 }
21460 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21461 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21462 }
21463 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21464 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21465 }
21466 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21467 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21468 }
21469 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21470 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21471 }
21472 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21473 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21474 }
21475 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21476 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21477 }
21478 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21479 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21480 }
21481 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21482 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21483 }
21484 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21485 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21486 }
21487 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21488 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21489 }
21490 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21491 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21492 }
21493 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21494 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21495 }
21496 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21497 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21498 }
21499 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21500 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21501 }
21502 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21503 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21504 }
21505 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21506 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21507 }
21508 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21509 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21510 }
21511 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21512 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21513 }
21514 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21515 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21516 }
21517 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21518 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21519 }
21520 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21521 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21522 }
21523 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21524 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21525 }
21526 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21527 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21528 }
21529 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21530 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21531 }
21532 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21533 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21534 }
21535 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21536 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21537 }
21538 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21539 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21540 }
21541 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21542 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21543 }
21544 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21545 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21546 }
21547 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21548 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21549 }
21550 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21551 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21552 }
21553 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21554 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21555 }
21556 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21557 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21558 }
21559 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21560 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21561 }
21562 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21563 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21564 }
21565 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21566 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21567 }
21568 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21569 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21570 }
21571 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21572 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21573 }
21574 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21575 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21576 }
21577 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21578 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21579 }
21580 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21581 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};
21582 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21583 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21584 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21585 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21586 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21587 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21588 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21589 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21590 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21591 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21592 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21593 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21594 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21595 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21596 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21597 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21598 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21599 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21600 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21601 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21602 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21603 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21604 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21605 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21606 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21607 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21608 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21609 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21610 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21611 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21612 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21613 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21614 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21615 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21616 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21617 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21618 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21619 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21620 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21621 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21622 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21623 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21624 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21625 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21626 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21627 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21628 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21629 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21630 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21631 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21632 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21633 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21634 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21635 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21636 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21637 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21638 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21639 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21640 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21641 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21642 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21643 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21644 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21645 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21646 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21647 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21648 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21649 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21650 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21651 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21652 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21653 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21654 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21655 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21656 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21657 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21658 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21659 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21660 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21661 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21662 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21663 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21664 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21665 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21666 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21667 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21668 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21669 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21670 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21671 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21672 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21673 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21674 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21675 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21676 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21677 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21678 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21679 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21680 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21681 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21682 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21683 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21684 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21685 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21686 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21687 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21688 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21689 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21690 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21691 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21692 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21693 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21694 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21695 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21696 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21697 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21698 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21699 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21700 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21701 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21702 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21703 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21704 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21705 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21706 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21707 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21708 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21709 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21710 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21711 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21712 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21713 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21714 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21715 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21716 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21717 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21718 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21719 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21720 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21721 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21722 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21723 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21724 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21725 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21726 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21727 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21728 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21729 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21730 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21731 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21732 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21733 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21734 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21735 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21736 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21737 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21738 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21739 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21740 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21741 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21742 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21743 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21744 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21745 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
21746 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
21747 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
21748 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
21749 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
21750 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
21751 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
21752 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
21753 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
21754 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
21755 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
21756 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
21757 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
21758 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
21759 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
21760 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
21761 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
21762 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
21763 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
21764 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
21765 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
21766
21767 static swig_type_info *swig_type_initial[] = {
21768 &_swigt__p_char,
21769 &_swigt__p_form_ops_t,
21770 &_swigt__p_int,
21771 &_swigt__p_long,
21772 &_swigt__p_unsigned_char,
21773 &_swigt__p_unsigned_int,
21774 &_swigt__p_unsigned_long,
21775 &_swigt__p_wxANIHandler,
21776 &_swigt__p_wxAcceleratorTable,
21777 &_swigt__p_wxActivateEvent,
21778 &_swigt__p_wxArrayString,
21779 &_swigt__p_wxBMPHandler,
21780 &_swigt__p_wxBoxSizer,
21781 &_swigt__p_wxCURHandler,
21782 &_swigt__p_wxCalculateLayoutEvent,
21783 &_swigt__p_wxChildFocusEvent,
21784 &_swigt__p_wxCloseEvent,
21785 &_swigt__p_wxColour,
21786 &_swigt__p_wxColourData,
21787 &_swigt__p_wxColourDialog,
21788 &_swigt__p_wxCommandEvent,
21789 &_swigt__p_wxContextMenuEvent,
21790 &_swigt__p_wxControl,
21791 &_swigt__p_wxControlWithItems,
21792 &_swigt__p_wxDC,
21793 &_swigt__p_wxDateEvent,
21794 &_swigt__p_wxDialog,
21795 &_swigt__p_wxDirDialog,
21796 &_swigt__p_wxDisplayChangedEvent,
21797 &_swigt__p_wxDropFilesEvent,
21798 &_swigt__p_wxDuplexMode,
21799 &_swigt__p_wxEraseEvent,
21800 &_swigt__p_wxEvent,
21801 &_swigt__p_wxEvtHandler,
21802 &_swigt__p_wxFSFile,
21803 &_swigt__p_wxFileDialog,
21804 &_swigt__p_wxFileSystem,
21805 &_swigt__p_wxFindDialogEvent,
21806 &_swigt__p_wxFindReplaceData,
21807 &_swigt__p_wxFindReplaceDialog,
21808 &_swigt__p_wxFlexGridSizer,
21809 &_swigt__p_wxFocusEvent,
21810 &_swigt__p_wxFont,
21811 &_swigt__p_wxFontData,
21812 &_swigt__p_wxFontDialog,
21813 &_swigt__p_wxFrame,
21814 &_swigt__p_wxGBSizerItem,
21815 &_swigt__p_wxGIFHandler,
21816 &_swigt__p_wxGrid,
21817 &_swigt__p_wxGridBagSizer,
21818 &_swigt__p_wxGridCellAttr,
21819 &_swigt__p_wxGridCellAttrProvider,
21820 &_swigt__p_wxGridCellAutoWrapStringEditor,
21821 &_swigt__p_wxGridCellAutoWrapStringRenderer,
21822 &_swigt__p_wxGridCellBoolEditor,
21823 &_swigt__p_wxGridCellBoolRenderer,
21824 &_swigt__p_wxGridCellChoiceEditor,
21825 &_swigt__p_wxGridCellCoords,
21826 &_swigt__p_wxGridCellDateTimeRenderer,
21827 &_swigt__p_wxGridCellEditor,
21828 &_swigt__p_wxGridCellEnumEditor,
21829 &_swigt__p_wxGridCellEnumRenderer,
21830 &_swigt__p_wxGridCellFloatEditor,
21831 &_swigt__p_wxGridCellFloatRenderer,
21832 &_swigt__p_wxGridCellNumberEditor,
21833 &_swigt__p_wxGridCellNumberRenderer,
21834 &_swigt__p_wxGridCellRenderer,
21835 &_swigt__p_wxGridCellStringRenderer,
21836 &_swigt__p_wxGridCellTextEditor,
21837 &_swigt__p_wxGridCellWorker,
21838 &_swigt__p_wxGridEditorCreatedEvent,
21839 &_swigt__p_wxGridEvent,
21840 &_swigt__p_wxGridRangeSelectEvent,
21841 &_swigt__p_wxGridSizeEvent,
21842 &_swigt__p_wxGridSizer,
21843 &_swigt__p_wxGridStringTable,
21844 &_swigt__p_wxGridTableBase,
21845 &_swigt__p_wxGridTableMessage,
21846 &_swigt__p_wxICOHandler,
21847 &_swigt__p_wxIconizeEvent,
21848 &_swigt__p_wxIdleEvent,
21849 &_swigt__p_wxImage,
21850 &_swigt__p_wxImageHandler,
21851 &_swigt__p_wxIndividualLayoutConstraint,
21852 &_swigt__p_wxInitDialogEvent,
21853 &_swigt__p_wxJPEGHandler,
21854 &_swigt__p_wxKeyEvent,
21855 &_swigt__p_wxLayoutAlgorithm,
21856 &_swigt__p_wxLayoutConstraints,
21857 &_swigt__p_wxMDIChildFrame,
21858 &_swigt__p_wxMDIClientWindow,
21859 &_swigt__p_wxMDIParentFrame,
21860 &_swigt__p_wxMaximizeEvent,
21861 &_swigt__p_wxMenu,
21862 &_swigt__p_wxMenuBar,
21863 &_swigt__p_wxMenuEvent,
21864 &_swigt__p_wxMenuItem,
21865 &_swigt__p_wxMessageDialog,
21866 &_swigt__p_wxMiniFrame,
21867 &_swigt__p_wxMouseCaptureChangedEvent,
21868 &_swigt__p_wxMouseEvent,
21869 &_swigt__p_wxMoveEvent,
21870 &_swigt__p_wxMultiChoiceDialog,
21871 &_swigt__p_wxNavigationKeyEvent,
21872 &_swigt__p_wxNcPaintEvent,
21873 &_swigt__p_wxNotifyEvent,
21874 &_swigt__p_wxObject,
21875 &_swigt__p_wxPCXHandler,
21876 &_swigt__p_wxPNGHandler,
21877 &_swigt__p_wxPNMHandler,
21878 &_swigt__p_wxPageSetupDialog,
21879 &_swigt__p_wxPageSetupDialogData,
21880 &_swigt__p_wxPaintEvent,
21881 &_swigt__p_wxPaletteChangedEvent,
21882 &_swigt__p_wxPanel,
21883 &_swigt__p_wxPaperSize,
21884 &_swigt__p_wxPasswordEntryDialog,
21885 &_swigt__p_wxPoint,
21886 &_swigt__p_wxPopupWindow,
21887 &_swigt__p_wxPreviewCanvas,
21888 &_swigt__p_wxPreviewControlBar,
21889 &_swigt__p_wxPreviewFrame,
21890 &_swigt__p_wxPrintData,
21891 &_swigt__p_wxPrintDialog,
21892 &_swigt__p_wxPrintDialogData,
21893 &_swigt__p_wxPrintPreview,
21894 &_swigt__p_wxPrinter,
21895 &_swigt__p_wxProgressDialog,
21896 &_swigt__p_wxPyApp,
21897 &_swigt__p_wxPyCommandEvent,
21898 &_swigt__p_wxPyEvent,
21899 &_swigt__p_wxPyGridCellAttrProvider,
21900 &_swigt__p_wxPyGridCellEditor,
21901 &_swigt__p_wxPyGridCellRenderer,
21902 &_swigt__p_wxPyGridTableBase,
21903 &_swigt__p_wxPyHtmlListBox,
21904 &_swigt__p_wxPyImageHandler,
21905 &_swigt__p_wxPyPanel,
21906 &_swigt__p_wxPyPopupTransientWindow,
21907 &_swigt__p_wxPyPreviewControlBar,
21908 &_swigt__p_wxPyPreviewFrame,
21909 &_swigt__p_wxPyPrintPreview,
21910 &_swigt__p_wxPyPrintout,
21911 &_swigt__p_wxPyScrolledWindow,
21912 &_swigt__p_wxPySizer,
21913 &_swigt__p_wxPyTaskBarIcon,
21914 &_swigt__p_wxPyVListBox,
21915 &_swigt__p_wxPyVScrolledWindow,
21916 &_swigt__p_wxPyValidator,
21917 &_swigt__p_wxPyWindow,
21918 &_swigt__p_wxQueryLayoutInfoEvent,
21919 &_swigt__p_wxQueryNewPaletteEvent,
21920 &_swigt__p_wxRect,
21921 &_swigt__p_wxSashEvent,
21922 &_swigt__p_wxSashLayoutWindow,
21923 &_swigt__p_wxSashWindow,
21924 &_swigt__p_wxScrollEvent,
21925 &_swigt__p_wxScrollWinEvent,
21926 &_swigt__p_wxScrolledWindow,
21927 &_swigt__p_wxSetCursorEvent,
21928 &_swigt__p_wxShowEvent,
21929 &_swigt__p_wxSingleChoiceDialog,
21930 &_swigt__p_wxSizeEvent,
21931 &_swigt__p_wxSizer,
21932 &_swigt__p_wxSizerItem,
21933 &_swigt__p_wxSplashScreen,
21934 &_swigt__p_wxSplashScreenWindow,
21935 &_swigt__p_wxSplitterEvent,
21936 &_swigt__p_wxSplitterWindow,
21937 &_swigt__p_wxStaticBoxSizer,
21938 &_swigt__p_wxStatusBar,
21939 &_swigt__p_wxStdDialogButtonSizer,
21940 &_swigt__p_wxString,
21941 &_swigt__p_wxSysColourChangedEvent,
21942 &_swigt__p_wxTIFFHandler,
21943 &_swigt__p_wxTaskBarIconEvent,
21944 &_swigt__p_wxTextEntryDialog,
21945 &_swigt__p_wxTipWindow,
21946 &_swigt__p_wxTopLevelWindow,
21947 &_swigt__p_wxUpdateUIEvent,
21948 &_swigt__p_wxValidator,
21949 &_swigt__p_wxVisualAttributes,
21950 &_swigt__p_wxWindow,
21951 &_swigt__p_wxWindowCreateEvent,
21952 &_swigt__p_wxWindowDestroyEvent,
21953 &_swigt__p_wxXPMHandler,
21954 };
21955
21956 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21957 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
21958 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21959 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
21960 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
21961 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21962 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
21963 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
21964 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
21965 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
21966 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
21967 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
21968 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
21969 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
21970 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21971 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
21972 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
21973 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
21974 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
21975 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
21976 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}};
21977 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
21978 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}};
21979 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
21980 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
21981 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21982 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
21983 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
21984 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
21985 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
21986 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
21987 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
21988 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
21989 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
21990 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
21991 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21992 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21993 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
21994 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21995 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
21996 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
21997 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
21998 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
21999 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22000 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22001 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22002 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22003 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22004 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22005 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22006 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22007 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22008 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22009 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}};
22010 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22011 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22012 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22013 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22014 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22015 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22016 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22017 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22018 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22019 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22020 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22021 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22022 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22023 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22024 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22025 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22026 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22027 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22028 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22029 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22030 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22031 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22032 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22033 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22034 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22035 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22036 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22037 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22038 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22039 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22040 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22041 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22042 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22043 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22044 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22045 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22046 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22047 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22048 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22049 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22050 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22051 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22052 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22053 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22054 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}};
22055 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22056 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22057 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22058 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}};
22059 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22060 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22061 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22062 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22063 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}};
22064 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22065 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22066 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}};
22067 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22068 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22069 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22070 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22071 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22072 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22073 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}};
22074 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}};
22075 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}};
22076 static swig_cast_info _swigc__p_wxGridCellWorker[] = { {&_swigt__p_wxGridCellChoiceEditor, _p_wxGridCellChoiceEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellEnumEditor, _p_wxGridCellEnumEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringEditor, _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellFloatEditor, _p_wxGridCellFloatEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellNumberEditor, _p_wxGridCellNumberEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellTextEditor, _p_wxGridCellTextEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxPyGridCellEditor, _p_wxPyGridCellEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellEditor, _p_wxGridCellEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellBoolEditor, _p_wxGridCellBoolEditorTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellWorker, 0, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringRenderer, _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellEnumRenderer, _p_wxGridCellEnumRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellDateTimeRenderer, _p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellBoolRenderer, _p_wxGridCellBoolRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellFloatRenderer, _p_wxGridCellFloatRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellNumberRenderer, _p_wxGridCellNumberRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellStringRenderer, _p_wxGridCellStringRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxPyGridCellRenderer, _p_wxPyGridCellRendererTo_p_wxGridCellWorker, 0, 0}, {&_swigt__p_wxGridCellRenderer, _p_wxGridCellRendererTo_p_wxGridCellWorker, 0, 0},{0, 0, 0, 0}};
22077 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22078 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22079 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22080 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22081 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22082 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}};
22083 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22084 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22085 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}};
22086 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22087 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22088 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22089 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22090 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22091 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22092 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22093 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22094 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22095 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22096 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22097 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22098 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22099 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22100 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22101 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22102 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22103 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22104 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22105 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22106 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22107 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22108 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22109 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22110 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22111 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22112 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22113 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22114 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22115 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22116 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22117 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22118 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22119 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22120 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22121 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22122 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22123 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22124 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22125 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22126 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22127 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22128 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22129 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}};
22130 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}};
22131 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22132 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22133 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22134 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22135 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22136 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22137 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22138 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}};
22139 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22140 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22141 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}};
22142
22143 static swig_cast_info *swig_cast_initial[] = {
22144 _swigc__p_char,
22145 _swigc__p_form_ops_t,
22146 _swigc__p_int,
22147 _swigc__p_long,
22148 _swigc__p_unsigned_char,
22149 _swigc__p_unsigned_int,
22150 _swigc__p_unsigned_long,
22151 _swigc__p_wxANIHandler,
22152 _swigc__p_wxAcceleratorTable,
22153 _swigc__p_wxActivateEvent,
22154 _swigc__p_wxArrayString,
22155 _swigc__p_wxBMPHandler,
22156 _swigc__p_wxBoxSizer,
22157 _swigc__p_wxCURHandler,
22158 _swigc__p_wxCalculateLayoutEvent,
22159 _swigc__p_wxChildFocusEvent,
22160 _swigc__p_wxCloseEvent,
22161 _swigc__p_wxColour,
22162 _swigc__p_wxColourData,
22163 _swigc__p_wxColourDialog,
22164 _swigc__p_wxCommandEvent,
22165 _swigc__p_wxContextMenuEvent,
22166 _swigc__p_wxControl,
22167 _swigc__p_wxControlWithItems,
22168 _swigc__p_wxDC,
22169 _swigc__p_wxDateEvent,
22170 _swigc__p_wxDialog,
22171 _swigc__p_wxDirDialog,
22172 _swigc__p_wxDisplayChangedEvent,
22173 _swigc__p_wxDropFilesEvent,
22174 _swigc__p_wxDuplexMode,
22175 _swigc__p_wxEraseEvent,
22176 _swigc__p_wxEvent,
22177 _swigc__p_wxEvtHandler,
22178 _swigc__p_wxFSFile,
22179 _swigc__p_wxFileDialog,
22180 _swigc__p_wxFileSystem,
22181 _swigc__p_wxFindDialogEvent,
22182 _swigc__p_wxFindReplaceData,
22183 _swigc__p_wxFindReplaceDialog,
22184 _swigc__p_wxFlexGridSizer,
22185 _swigc__p_wxFocusEvent,
22186 _swigc__p_wxFont,
22187 _swigc__p_wxFontData,
22188 _swigc__p_wxFontDialog,
22189 _swigc__p_wxFrame,
22190 _swigc__p_wxGBSizerItem,
22191 _swigc__p_wxGIFHandler,
22192 _swigc__p_wxGrid,
22193 _swigc__p_wxGridBagSizer,
22194 _swigc__p_wxGridCellAttr,
22195 _swigc__p_wxGridCellAttrProvider,
22196 _swigc__p_wxGridCellAutoWrapStringEditor,
22197 _swigc__p_wxGridCellAutoWrapStringRenderer,
22198 _swigc__p_wxGridCellBoolEditor,
22199 _swigc__p_wxGridCellBoolRenderer,
22200 _swigc__p_wxGridCellChoiceEditor,
22201 _swigc__p_wxGridCellCoords,
22202 _swigc__p_wxGridCellDateTimeRenderer,
22203 _swigc__p_wxGridCellEditor,
22204 _swigc__p_wxGridCellEnumEditor,
22205 _swigc__p_wxGridCellEnumRenderer,
22206 _swigc__p_wxGridCellFloatEditor,
22207 _swigc__p_wxGridCellFloatRenderer,
22208 _swigc__p_wxGridCellNumberEditor,
22209 _swigc__p_wxGridCellNumberRenderer,
22210 _swigc__p_wxGridCellRenderer,
22211 _swigc__p_wxGridCellStringRenderer,
22212 _swigc__p_wxGridCellTextEditor,
22213 _swigc__p_wxGridCellWorker,
22214 _swigc__p_wxGridEditorCreatedEvent,
22215 _swigc__p_wxGridEvent,
22216 _swigc__p_wxGridRangeSelectEvent,
22217 _swigc__p_wxGridSizeEvent,
22218 _swigc__p_wxGridSizer,
22219 _swigc__p_wxGridStringTable,
22220 _swigc__p_wxGridTableBase,
22221 _swigc__p_wxGridTableMessage,
22222 _swigc__p_wxICOHandler,
22223 _swigc__p_wxIconizeEvent,
22224 _swigc__p_wxIdleEvent,
22225 _swigc__p_wxImage,
22226 _swigc__p_wxImageHandler,
22227 _swigc__p_wxIndividualLayoutConstraint,
22228 _swigc__p_wxInitDialogEvent,
22229 _swigc__p_wxJPEGHandler,
22230 _swigc__p_wxKeyEvent,
22231 _swigc__p_wxLayoutAlgorithm,
22232 _swigc__p_wxLayoutConstraints,
22233 _swigc__p_wxMDIChildFrame,
22234 _swigc__p_wxMDIClientWindow,
22235 _swigc__p_wxMDIParentFrame,
22236 _swigc__p_wxMaximizeEvent,
22237 _swigc__p_wxMenu,
22238 _swigc__p_wxMenuBar,
22239 _swigc__p_wxMenuEvent,
22240 _swigc__p_wxMenuItem,
22241 _swigc__p_wxMessageDialog,
22242 _swigc__p_wxMiniFrame,
22243 _swigc__p_wxMouseCaptureChangedEvent,
22244 _swigc__p_wxMouseEvent,
22245 _swigc__p_wxMoveEvent,
22246 _swigc__p_wxMultiChoiceDialog,
22247 _swigc__p_wxNavigationKeyEvent,
22248 _swigc__p_wxNcPaintEvent,
22249 _swigc__p_wxNotifyEvent,
22250 _swigc__p_wxObject,
22251 _swigc__p_wxPCXHandler,
22252 _swigc__p_wxPNGHandler,
22253 _swigc__p_wxPNMHandler,
22254 _swigc__p_wxPageSetupDialog,
22255 _swigc__p_wxPageSetupDialogData,
22256 _swigc__p_wxPaintEvent,
22257 _swigc__p_wxPaletteChangedEvent,
22258 _swigc__p_wxPanel,
22259 _swigc__p_wxPaperSize,
22260 _swigc__p_wxPasswordEntryDialog,
22261 _swigc__p_wxPoint,
22262 _swigc__p_wxPopupWindow,
22263 _swigc__p_wxPreviewCanvas,
22264 _swigc__p_wxPreviewControlBar,
22265 _swigc__p_wxPreviewFrame,
22266 _swigc__p_wxPrintData,
22267 _swigc__p_wxPrintDialog,
22268 _swigc__p_wxPrintDialogData,
22269 _swigc__p_wxPrintPreview,
22270 _swigc__p_wxPrinter,
22271 _swigc__p_wxProgressDialog,
22272 _swigc__p_wxPyApp,
22273 _swigc__p_wxPyCommandEvent,
22274 _swigc__p_wxPyEvent,
22275 _swigc__p_wxPyGridCellAttrProvider,
22276 _swigc__p_wxPyGridCellEditor,
22277 _swigc__p_wxPyGridCellRenderer,
22278 _swigc__p_wxPyGridTableBase,
22279 _swigc__p_wxPyHtmlListBox,
22280 _swigc__p_wxPyImageHandler,
22281 _swigc__p_wxPyPanel,
22282 _swigc__p_wxPyPopupTransientWindow,
22283 _swigc__p_wxPyPreviewControlBar,
22284 _swigc__p_wxPyPreviewFrame,
22285 _swigc__p_wxPyPrintPreview,
22286 _swigc__p_wxPyPrintout,
22287 _swigc__p_wxPyScrolledWindow,
22288 _swigc__p_wxPySizer,
22289 _swigc__p_wxPyTaskBarIcon,
22290 _swigc__p_wxPyVListBox,
22291 _swigc__p_wxPyVScrolledWindow,
22292 _swigc__p_wxPyValidator,
22293 _swigc__p_wxPyWindow,
22294 _swigc__p_wxQueryLayoutInfoEvent,
22295 _swigc__p_wxQueryNewPaletteEvent,
22296 _swigc__p_wxRect,
22297 _swigc__p_wxSashEvent,
22298 _swigc__p_wxSashLayoutWindow,
22299 _swigc__p_wxSashWindow,
22300 _swigc__p_wxScrollEvent,
22301 _swigc__p_wxScrollWinEvent,
22302 _swigc__p_wxScrolledWindow,
22303 _swigc__p_wxSetCursorEvent,
22304 _swigc__p_wxShowEvent,
22305 _swigc__p_wxSingleChoiceDialog,
22306 _swigc__p_wxSizeEvent,
22307 _swigc__p_wxSizer,
22308 _swigc__p_wxSizerItem,
22309 _swigc__p_wxSplashScreen,
22310 _swigc__p_wxSplashScreenWindow,
22311 _swigc__p_wxSplitterEvent,
22312 _swigc__p_wxSplitterWindow,
22313 _swigc__p_wxStaticBoxSizer,
22314 _swigc__p_wxStatusBar,
22315 _swigc__p_wxStdDialogButtonSizer,
22316 _swigc__p_wxString,
22317 _swigc__p_wxSysColourChangedEvent,
22318 _swigc__p_wxTIFFHandler,
22319 _swigc__p_wxTaskBarIconEvent,
22320 _swigc__p_wxTextEntryDialog,
22321 _swigc__p_wxTipWindow,
22322 _swigc__p_wxTopLevelWindow,
22323 _swigc__p_wxUpdateUIEvent,
22324 _swigc__p_wxValidator,
22325 _swigc__p_wxVisualAttributes,
22326 _swigc__p_wxWindow,
22327 _swigc__p_wxWindowCreateEvent,
22328 _swigc__p_wxWindowDestroyEvent,
22329 _swigc__p_wxXPMHandler,
22330 };
22331
22332
22333 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22334
22335 static swig_const_info swig_const_table[] = {
22336 {0, 0, 0, 0.0, 0, 0}};
22337
22338 #ifdef __cplusplus
22339 }
22340 #endif
22341 /* -----------------------------------------------------------------------------
22342 * Type initialization:
22343 * This problem is tough by the requirement that no dynamic
22344 * memory is used. Also, since swig_type_info structures store pointers to
22345 * swig_cast_info structures and swig_cast_info structures store pointers back
22346 * to swig_type_info structures, we need some lookup code at initialization.
22347 * The idea is that swig generates all the structures that are needed.
22348 * The runtime then collects these partially filled structures.
22349 * The SWIG_InitializeModule function takes these initial arrays out of
22350 * swig_module, and does all the lookup, filling in the swig_module.types
22351 * array with the correct data and linking the correct swig_cast_info
22352 * structures together.
22353 *
22354 * The generated swig_type_info structures are assigned staticly to an initial
22355 * array. We just loop though that array, and handle each type individually.
22356 * First we lookup if this type has been already loaded, and if so, use the
22357 * loaded structure instead of the generated one. Then we have to fill in the
22358 * cast linked list. The cast data is initially stored in something like a
22359 * two-dimensional array. Each row corresponds to a type (there are the same
22360 * number of rows as there are in the swig_type_initial array). Each entry in
22361 * a column is one of the swig_cast_info structures for that type.
22362 * The cast_initial array is actually an array of arrays, because each row has
22363 * a variable number of columns. So to actually build the cast linked list,
22364 * we find the array of casts associated with the type, and loop through it
22365 * adding the casts to the list. The one last trick we need to do is making
22366 * sure the type pointer in the swig_cast_info struct is correct.
22367 *
22368 * First off, we lookup the cast->type name to see if it is already loaded.
22369 * There are three cases to handle:
22370 * 1) If the cast->type has already been loaded AND the type we are adding
22371 * casting info to has not been loaded (it is in this module), THEN we
22372 * replace the cast->type pointer with the type pointer that has already
22373 * been loaded.
22374 * 2) If BOTH types (the one we are adding casting info to, and the
22375 * cast->type) are loaded, THEN the cast info has already been loaded by
22376 * the previous module so we just ignore it.
22377 * 3) Finally, if cast->type has not already been loaded, then we add that
22378 * swig_cast_info to the linked list (because the cast->type) pointer will
22379 * be correct.
22380 * ----------------------------------------------------------------------------- */
22381
22382 #ifdef __cplusplus
22383 extern "C" {
22384 #if 0
22385 } /* c-mode */
22386 #endif
22387 #endif
22388
22389 #if 0
22390 #define SWIGRUNTIME_DEBUG
22391 #endif
22392
22393 SWIGRUNTIME void
22394 SWIG_InitializeModule(void *clientdata) {
22395 size_t i;
22396 swig_module_info *module_head;
22397 static int init_run = 0;
22398
22399 clientdata = clientdata;
22400
22401 if (init_run) return;
22402 init_run = 1;
22403
22404 /* Initialize the swig_module */
22405 swig_module.type_initial = swig_type_initial;
22406 swig_module.cast_initial = swig_cast_initial;
22407
22408 /* Try and load any already created modules */
22409 module_head = SWIG_GetModule(clientdata);
22410 if (module_head) {
22411 swig_module.next = module_head->next;
22412 module_head->next = &swig_module;
22413 } else {
22414 /* This is the first module loaded */
22415 swig_module.next = &swig_module;
22416 SWIG_SetModule(clientdata, &swig_module);
22417 }
22418
22419 /* Now work on filling in swig_module.types */
22420 #ifdef SWIGRUNTIME_DEBUG
22421 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22422 #endif
22423 for (i = 0; i < swig_module.size; ++i) {
22424 swig_type_info *type = 0;
22425 swig_type_info *ret;
22426 swig_cast_info *cast;
22427
22428 #ifdef SWIGRUNTIME_DEBUG
22429 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22430 #endif
22431
22432 /* if there is another module already loaded */
22433 if (swig_module.next != &swig_module) {
22434 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22435 }
22436 if (type) {
22437 /* Overwrite clientdata field */
22438 #ifdef SWIGRUNTIME_DEBUG
22439 printf("SWIG_InitializeModule: found type %s\n", type->name);
22440 #endif
22441 if (swig_module.type_initial[i]->clientdata) {
22442 type->clientdata = swig_module.type_initial[i]->clientdata;
22443 #ifdef SWIGRUNTIME_DEBUG
22444 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22445 #endif
22446 }
22447 } else {
22448 type = swig_module.type_initial[i];
22449 }
22450
22451 /* Insert casting types */
22452 cast = swig_module.cast_initial[i];
22453 while (cast->type) {
22454 /* Don't need to add information already in the list */
22455 ret = 0;
22456 #ifdef SWIGRUNTIME_DEBUG
22457 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22458 #endif
22459 if (swig_module.next != &swig_module) {
22460 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22461 #ifdef SWIGRUNTIME_DEBUG
22462 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22463 #endif
22464 }
22465 if (ret) {
22466 if (type == swig_module.type_initial[i]) {
22467 #ifdef SWIGRUNTIME_DEBUG
22468 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22469 #endif
22470 cast->type = ret;
22471 ret = 0;
22472 } else {
22473 /* Check for casting already in the list */
22474 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22475 #ifdef SWIGRUNTIME_DEBUG
22476 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22477 #endif
22478 if (!ocast) ret = 0;
22479 }
22480 }
22481
22482 if (!ret) {
22483 #ifdef SWIGRUNTIME_DEBUG
22484 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22485 #endif
22486 if (type->cast) {
22487 type->cast->prev = cast;
22488 cast->next = type->cast;
22489 }
22490 type->cast = cast;
22491 }
22492 cast++;
22493 }
22494 /* Set entry in modules->types array equal to the type */
22495 swig_module.types[i] = type;
22496 }
22497 swig_module.types[i] = 0;
22498
22499 #ifdef SWIGRUNTIME_DEBUG
22500 printf("**** SWIG_InitializeModule: Cast List ******\n");
22501 for (i = 0; i < swig_module.size; ++i) {
22502 int j = 0;
22503 swig_cast_info *cast = swig_module.cast_initial[i];
22504 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22505 while (cast->type) {
22506 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22507 cast++;
22508 ++j;
22509 }
22510 printf("---- Total casts: %d\n",j);
22511 }
22512 printf("**** SWIG_InitializeModule: Cast List ******\n");
22513 #endif
22514 }
22515
22516 /* This function will propagate the clientdata field of type to
22517 * any new swig_type_info structures that have been added into the list
22518 * of equivalent types. It is like calling
22519 * SWIG_TypeClientData(type, clientdata) a second time.
22520 */
22521 SWIGRUNTIME void
22522 SWIG_PropagateClientData(void) {
22523 size_t i;
22524 swig_cast_info *equiv;
22525 static int init_run = 0;
22526
22527 if (init_run) return;
22528 init_run = 1;
22529
22530 for (i = 0; i < swig_module.size; i++) {
22531 if (swig_module.types[i]->clientdata) {
22532 equiv = swig_module.types[i]->cast;
22533 while (equiv) {
22534 if (!equiv->converter) {
22535 if (equiv->type && !equiv->type->clientdata)
22536 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22537 }
22538 equiv = equiv->next;
22539 }
22540 }
22541 }
22542 }
22543
22544 #ifdef __cplusplus
22545 #if 0
22546 {
22547 /* c-mode */
22548 #endif
22549 }
22550 #endif
22551
22552
22553
22554 #ifdef __cplusplus
22555 extern "C" {
22556 #endif
22557
22558 /* Python-specific SWIG API */
22559 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22560 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22561 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22562
22563 /* -----------------------------------------------------------------------------
22564 * global variable support code.
22565 * ----------------------------------------------------------------------------- */
22566
22567 typedef struct swig_globalvar {
22568 char *name; /* Name of global variable */
22569 PyObject *(*get_attr)(void); /* Return the current value */
22570 int (*set_attr)(PyObject *); /* Set the value */
22571 struct swig_globalvar *next;
22572 } swig_globalvar;
22573
22574 typedef struct swig_varlinkobject {
22575 PyObject_HEAD
22576 swig_globalvar *vars;
22577 } swig_varlinkobject;
22578
22579 SWIGINTERN PyObject *
22580 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22581 return PyString_FromString("<Swig global variables>");
22582 }
22583
22584 SWIGINTERN PyObject *
22585 swig_varlink_str(swig_varlinkobject *v) {
22586 PyObject *str = PyString_FromString("(");
22587 swig_globalvar *var;
22588 for (var = v->vars; var; var=var->next) {
22589 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22590 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22591 }
22592 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22593 return str;
22594 }
22595
22596 SWIGINTERN int
22597 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22598 PyObject *str = swig_varlink_str(v);
22599 fprintf(fp,"Swig global variables ");
22600 fprintf(fp,"%s\n", PyString_AsString(str));
22601 Py_DECREF(str);
22602 return 0;
22603 }
22604
22605 SWIGINTERN void
22606 swig_varlink_dealloc(swig_varlinkobject *v) {
22607 swig_globalvar *var = v->vars;
22608 while (var) {
22609 swig_globalvar *n = var->next;
22610 free(var->name);
22611 free(var);
22612 var = n;
22613 }
22614 }
22615
22616 SWIGINTERN PyObject *
22617 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22618 PyObject *res = NULL;
22619 swig_globalvar *var = v->vars;
22620 while (var) {
22621 if (strcmp(var->name,n) == 0) {
22622 res = (*var->get_attr)();
22623 break;
22624 }
22625 var = var->next;
22626 }
22627 if (res == NULL && !PyErr_Occurred()) {
22628 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22629 }
22630 return res;
22631 }
22632
22633 SWIGINTERN int
22634 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22635 int res = 1;
22636 swig_globalvar *var = v->vars;
22637 while (var) {
22638 if (strcmp(var->name,n) == 0) {
22639 res = (*var->set_attr)(p);
22640 break;
22641 }
22642 var = var->next;
22643 }
22644 if (res == 1 && !PyErr_Occurred()) {
22645 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22646 }
22647 return res;
22648 }
22649
22650 SWIGINTERN PyTypeObject*
22651 swig_varlink_type(void) {
22652 static char varlink__doc__[] = "Swig var link object";
22653 static PyTypeObject varlink_type;
22654 static int type_init = 0;
22655 if (!type_init) {
22656 const PyTypeObject tmp
22657 = {
22658 PyObject_HEAD_INIT(NULL)
22659 0, /* Number of items in variable part (ob_size) */
22660 (char *)"swigvarlink", /* Type name (tp_name) */
22661 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22662 0, /* Itemsize (tp_itemsize) */
22663 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22664 (printfunc) swig_varlink_print, /* Print (tp_print) */
22665 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22666 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22667 0, /* tp_compare */
22668 (reprfunc) swig_varlink_repr, /* tp_repr */
22669 0, /* tp_as_number */
22670 0, /* tp_as_sequence */
22671 0, /* tp_as_mapping */
22672 0, /* tp_hash */
22673 0, /* tp_call */
22674 (reprfunc)swig_varlink_str, /* tp_str */
22675 0, /* tp_getattro */
22676 0, /* tp_setattro */
22677 0, /* tp_as_buffer */
22678 0, /* tp_flags */
22679 varlink__doc__, /* tp_doc */
22680 0, /* tp_traverse */
22681 0, /* tp_clear */
22682 0, /* tp_richcompare */
22683 0, /* tp_weaklistoffset */
22684 #if PY_VERSION_HEX >= 0x02020000
22685 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22686 #endif
22687 #if PY_VERSION_HEX >= 0x02030000
22688 0, /* tp_del */
22689 #endif
22690 #ifdef COUNT_ALLOCS
22691 0,0,0,0 /* tp_alloc -> tp_next */
22692 #endif
22693 };
22694 varlink_type = tmp;
22695 varlink_type.ob_type = &PyType_Type;
22696 type_init = 1;
22697 }
22698 return &varlink_type;
22699 }
22700
22701 /* Create a variable linking object for use later */
22702 SWIGINTERN PyObject *
22703 SWIG_Python_newvarlink(void) {
22704 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22705 if (result) {
22706 result->vars = 0;
22707 }
22708 return ((PyObject*) result);
22709 }
22710
22711 SWIGINTERN void
22712 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22713 swig_varlinkobject *v = (swig_varlinkobject *) p;
22714 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22715 if (gv) {
22716 size_t size = strlen(name)+1;
22717 gv->name = (char *)malloc(size);
22718 if (gv->name) {
22719 strncpy(gv->name,name,size);
22720 gv->get_attr = get_attr;
22721 gv->set_attr = set_attr;
22722 gv->next = v->vars;
22723 }
22724 }
22725 v->vars = gv;
22726 }
22727
22728 SWIGINTERN PyObject *
22729 SWIG_globals() {
22730 static PyObject *_SWIG_globals = 0;
22731 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22732 return _SWIG_globals;
22733 }
22734
22735 /* -----------------------------------------------------------------------------
22736 * constants/methods manipulation
22737 * ----------------------------------------------------------------------------- */
22738
22739 /* Install Constants */
22740 SWIGINTERN void
22741 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22742 PyObject *obj = 0;
22743 size_t i;
22744 for (i = 0; constants[i].type; ++i) {
22745 switch(constants[i].type) {
22746 case SWIG_PY_POINTER:
22747 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22748 break;
22749 case SWIG_PY_BINARY:
22750 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22751 break;
22752 default:
22753 obj = 0;
22754 break;
22755 }
22756 if (obj) {
22757 PyDict_SetItemString(d, constants[i].name, obj);
22758 Py_DECREF(obj);
22759 }
22760 }
22761 }
22762
22763 /* -----------------------------------------------------------------------------*/
22764 /* Fix SwigMethods to carry the callback ptrs when needed */
22765 /* -----------------------------------------------------------------------------*/
22766
22767 SWIGINTERN void
22768 SWIG_Python_FixMethods(PyMethodDef *methods,
22769 swig_const_info *const_table,
22770 swig_type_info **types,
22771 swig_type_info **types_initial) {
22772 size_t i;
22773 for (i = 0; methods[i].ml_name; ++i) {
22774 char *c = methods[i].ml_doc;
22775 if (c && (c = strstr(c, "swig_ptr: "))) {
22776 int j;
22777 swig_const_info *ci = 0;
22778 char *name = c + 10;
22779 for (j = 0; const_table[j].type; ++j) {
22780 if (strncmp(const_table[j].name, name,
22781 strlen(const_table[j].name)) == 0) {
22782 ci = &(const_table[j]);
22783 break;
22784 }
22785 }
22786 if (ci) {
22787 size_t shift = (ci->ptype) - types;
22788 swig_type_info *ty = types_initial[shift];
22789 size_t ldoc = (c - methods[i].ml_doc);
22790 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22791 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22792 if (ndoc) {
22793 char *buff = ndoc;
22794 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22795 if (ptr) {
22796 strncpy(buff, methods[i].ml_doc, ldoc);
22797 buff += ldoc;
22798 strncpy(buff, "swig_ptr: ", 10);
22799 buff += 10;
22800 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22801 methods[i].ml_doc = ndoc;
22802 }
22803 }
22804 }
22805 }
22806 }
22807 }
22808
22809 #ifdef __cplusplus
22810 }
22811 #endif
22812
22813 /* -----------------------------------------------------------------------------*
22814 * Partial Init method
22815 * -----------------------------------------------------------------------------*/
22816
22817 #ifdef __cplusplus
22818 extern "C"
22819 #endif
22820 SWIGEXPORT void SWIG_init(void) {
22821 PyObject *m, *d;
22822
22823 /* Fix SwigMethods to carry the callback ptrs when needed */
22824 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
22825
22826 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22827 d = PyModule_GetDict(m);
22828
22829 SWIG_InitializeModule(0);
22830 SWIG_InstallConstants(d,swig_const_table);
22831
22832
22833 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
22834 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
22835 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
22836 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
22837 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
22838 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
22839 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
22840 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
22841 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
22842 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
22843 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
22844 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
22845 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
22846 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
22847 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
22848 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
22849 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
22850 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
22851 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
22852 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
22853 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
22854 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
22855 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
22856 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
22857 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
22858 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
22859 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
22860 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
22861 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
22862 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
22863 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
22864 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
22865 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
22866 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
22867 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
22868 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
22869 SWIG_Python_SetConstant(d, "Grid_GridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
22870 SWIG_Python_SetConstant(d, "Grid_GridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
22871 SWIG_Python_SetConstant(d, "Grid_GridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
22872 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
22873 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
22874 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
22875 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
22876 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
22877 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
22878 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
22879 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
22880 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
22881 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
22882 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
22883 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
22884 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
22885 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
22886 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
22887 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
22888 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
22889
22890
22891 }
22892
wxWidgets (Impactor)