]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / 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_wxClipboardTextEvent swig_types[16]
2479 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2480 #define SWIGTYPE_p_wxColour swig_types[18]
2481 #define SWIGTYPE_p_wxColourData swig_types[19]
2482 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2483 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2484 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2485 #define SWIGTYPE_p_wxControl swig_types[23]
2486 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2487 #define SWIGTYPE_p_wxDC swig_types[25]
2488 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2489 #define SWIGTYPE_p_wxDialog swig_types[27]
2490 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2491 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2494 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2495 #define SWIGTYPE_p_wxEvent swig_types[33]
2496 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2497 #define SWIGTYPE_p_wxFSFile swig_types[35]
2498 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2499 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2500 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2501 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2502 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2503 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2504 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2505 #define SWIGTYPE_p_wxFont swig_types[43]
2506 #define SWIGTYPE_p_wxFontData swig_types[44]
2507 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2511 #define SWIGTYPE_p_wxGrid swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2514 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2515 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2516 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2517 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2518 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2519 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2520 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2521 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2522 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2523 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2524 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2525 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2526 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2527 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2528 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2529 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2530 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2531 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2532 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2533 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2534 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2535 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2536 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2537 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2538 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2539 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2540 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2541 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2542 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2543 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2544 #define SWIGTYPE_p_wxImage swig_types[82]
2545 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2546 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2547 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2548 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2550 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2551 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2552 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2553 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2554 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2556 #define SWIGTYPE_p_wxMenu swig_types[94]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2560 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2561 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[101]
2564 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2565 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[103]
2566 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2567 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2568 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2569 #define SWIGTYPE_p_wxObject swig_types[107]
2570 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2573 #define SWIGTYPE_p_wxPageSetupDialog swig_types[111]
2574 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[112]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[114]
2577 #define SWIGTYPE_p_wxPanel swig_types[115]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[116]
2579 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[117]
2580 #define SWIGTYPE_p_wxPoint swig_types[118]
2581 #define SWIGTYPE_p_wxPopupWindow swig_types[119]
2582 #define SWIGTYPE_p_wxPreviewCanvas swig_types[120]
2583 #define SWIGTYPE_p_wxPreviewControlBar swig_types[121]
2584 #define SWIGTYPE_p_wxPreviewFrame swig_types[122]
2585 #define SWIGTYPE_p_wxPrintData swig_types[123]
2586 #define SWIGTYPE_p_wxPrintDialog swig_types[124]
2587 #define SWIGTYPE_p_wxPrintDialogData swig_types[125]
2588 #define SWIGTYPE_p_wxPrintPreview swig_types[126]
2589 #define SWIGTYPE_p_wxPrinter swig_types[127]
2590 #define SWIGTYPE_p_wxProgressDialog swig_types[128]
2591 #define SWIGTYPE_p_wxPyApp swig_types[129]
2592 #define SWIGTYPE_p_wxPyCommandEvent swig_types[130]
2593 #define SWIGTYPE_p_wxPyEvent swig_types[131]
2594 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[132]
2595 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[133]
2596 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[134]
2597 #define SWIGTYPE_p_wxPyGridTableBase swig_types[135]
2598 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[136]
2599 #define SWIGTYPE_p_wxPyImageHandler swig_types[137]
2600 #define SWIGTYPE_p_wxPyPanel swig_types[138]
2601 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[139]
2602 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[140]
2603 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[141]
2604 #define SWIGTYPE_p_wxPyPrintPreview swig_types[142]
2605 #define SWIGTYPE_p_wxPyPrintout swig_types[143]
2606 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[144]
2607 #define SWIGTYPE_p_wxPySizer swig_types[145]
2608 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[146]
2609 #define SWIGTYPE_p_wxPyVListBox swig_types[147]
2610 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[148]
2611 #define SWIGTYPE_p_wxPyValidator swig_types[149]
2612 #define SWIGTYPE_p_wxPyWindow swig_types[150]
2613 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[151]
2614 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[152]
2615 #define SWIGTYPE_p_wxRect swig_types[153]
2616 #define SWIGTYPE_p_wxSashEvent swig_types[154]
2617 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[155]
2618 #define SWIGTYPE_p_wxSashWindow swig_types[156]
2619 #define SWIGTYPE_p_wxScrollEvent swig_types[157]
2620 #define SWIGTYPE_p_wxScrollWinEvent swig_types[158]
2621 #define SWIGTYPE_p_wxScrolledWindow swig_types[159]
2622 #define SWIGTYPE_p_wxSetCursorEvent swig_types[160]
2623 #define SWIGTYPE_p_wxShowEvent swig_types[161]
2624 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[162]
2625 #define SWIGTYPE_p_wxSizeEvent swig_types[163]
2626 #define SWIGTYPE_p_wxSizer swig_types[164]
2627 #define SWIGTYPE_p_wxSizerItem swig_types[165]
2628 #define SWIGTYPE_p_wxSplashScreen swig_types[166]
2629 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[167]
2630 #define SWIGTYPE_p_wxSplitterEvent swig_types[168]
2631 #define SWIGTYPE_p_wxSplitterWindow swig_types[169]
2632 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[170]
2633 #define SWIGTYPE_p_wxStatusBar swig_types[171]
2634 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[172]
2635 #define SWIGTYPE_p_wxString swig_types[173]
2636 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[174]
2637 #define SWIGTYPE_p_wxTIFFHandler swig_types[175]
2638 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[176]
2639 #define SWIGTYPE_p_wxTextEntryDialog swig_types[177]
2640 #define SWIGTYPE_p_wxTipWindow swig_types[178]
2641 #define SWIGTYPE_p_wxTopLevelWindow swig_types[179]
2642 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[180]
2643 #define SWIGTYPE_p_wxValidator swig_types[181]
2644 #define SWIGTYPE_p_wxVisualAttributes swig_types[182]
2645 #define SWIGTYPE_p_wxWindow swig_types[183]
2646 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[184]
2647 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[185]
2648 #define SWIGTYPE_p_wxXPMHandler swig_types[186]
2649 static swig_type_info *swig_types[188];
2650 static swig_module_info swig_module = {swig_types, 187, 0, 0, 0, 0};
2651 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2652 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2653
2654 /* -------- TYPES TABLE (END) -------- */
2655
2656 #if (PY_VERSION_HEX <= 0x02000000)
2657 # if !defined(SWIG_PYTHON_CLASSIC)
2658 # error "This python version requires to use swig with the '-classic' option"
2659 # endif
2660 #endif
2661 #if (PY_VERSION_HEX <= 0x02020000)
2662 # error "This python version requires to use swig with the '-nomodern' option"
2663 #endif
2664 #if (PY_VERSION_HEX <= 0x02020000)
2665 # error "This python version requires to use swig with the '-nomodernargs' option"
2666 #endif
2667 #ifndef METH_O
2668 # error "This python version requires to use swig with the '-nofastunpack' option"
2669 #endif
2670
2671 /*-----------------------------------------------
2672 @(target):= _grid.so
2673 ------------------------------------------------*/
2674 #define SWIG_init init_grid
2675
2676 #define SWIG_name "_grid"
2677
2678 #define SWIGVERSION 0x010329
2679
2680
2681 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2682 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2683
2684
2685 #include <stdexcept>
2686
2687
2688 namespace swig {
2689 class PyObject_ptr {
2690 protected:
2691 PyObject *_obj;
2692
2693 public:
2694 PyObject_ptr() :_obj(0)
2695 {
2696 }
2697
2698 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2699 {
2700 Py_XINCREF(_obj);
2701 }
2702
2703 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2704 {
2705 if (initial_ref) Py_XINCREF(_obj);
2706 }
2707
2708 PyObject_ptr & operator=(const PyObject_ptr& item)
2709 {
2710 Py_XINCREF(item._obj);
2711 Py_XDECREF(_obj);
2712 _obj = item._obj;
2713 return *this;
2714 }
2715
2716 ~PyObject_ptr()
2717 {
2718 Py_XDECREF(_obj);
2719 }
2720
2721 operator PyObject *() const
2722 {
2723 return _obj;
2724 }
2725
2726 PyObject *operator->() const
2727 {
2728 return _obj;
2729 }
2730 };
2731 }
2732
2733
2734 namespace swig {
2735 struct PyObject_var : PyObject_ptr {
2736 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2737
2738 PyObject_var & operator = (PyObject* obj)
2739 {
2740 Py_XDECREF(_obj);
2741 _obj = obj;
2742 return *this;
2743 }
2744 };
2745 }
2746
2747
2748 #include "wx/wxPython/wxPython.h"
2749 #include "wx/wxPython/pyclasses.h"
2750 #include "wx/wxPython/printfw.h"
2751
2752 #include <wx/grid.h>
2753 #include <wx/generic/gridctrl.h>
2754
2755
2756 static const wxString wxPyEmptyString(wxEmptyString);
2757 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2758 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2759
2760
2761 #define wxPyMake_TEMPLATE(TYPE) \
2762 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2763 PyObject* target = NULL; \
2764 if (source) { \
2765 /* Check if there is already a pointer to a Python object in the \
2766 OOR data that we can use. */ \
2767 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2768 if (data) { \
2769 target = data->m_obj; \
2770 if (target) \
2771 Py_INCREF(target); \
2772 } \
2773 /* Otherwise make a new wrapper for it the old fashioned way and \
2774 give it the OOR treatment */ \
2775 if (! target) { \
2776 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2777 if (target) \
2778 source->SetClientObject(new wxPyOORClientData(target)); \
2779 } \
2780 } else { /* source was NULL so return None. */ \
2781 Py_INCREF(Py_None); target = Py_None; \
2782 } \
2783 return target; \
2784 } \
2785
2786
2787 wxPyMake_TEMPLATE(wxGridCellRenderer)
2788 wxPyMake_TEMPLATE(wxGridCellEditor)
2789 wxPyMake_TEMPLATE(wxGridCellAttr)
2790 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2791 wxPyMake_TEMPLATE(wxGridTableBase)
2792
2793
2794
2795 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2796 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2797 wxGridCellAttr* rval = NULL; \
2798 bool found; \
2799 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2800 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2801 PyObject* ro; \
2802 wxGridCellAttr* ptr; \
2803 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2804 if (ro) { \
2805 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2806 rval = ptr; \
2807 Py_DECREF(ro); \
2808 } \
2809 } \
2810 wxPyEndBlockThreads(blocked); \
2811 if (! found) \
2812 rval = PCLASS::CBNAME(a, b, c); \
2813 return rval; \
2814 }
2815
2816
2817 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2818 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2819 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2820 bool found; \
2821 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2822 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2823 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2824 Py_DECREF(obj); \
2825 } \
2826 wxPyEndBlockThreads(blocked); \
2827 if (! found) \
2828 PCLASS::CBNAME(attr, a, b); \
2829 }
2830
2831
2832
2833 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2834 void CBNAME(wxGridCellAttr *attr, int val) { \
2835 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2836 bool found; \
2837 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2838 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2839 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2840 Py_DECREF(obj); \
2841 } \
2842 wxPyEndBlockThreads(blocked); \
2843 if (! found) \
2844 PCLASS::CBNAME(attr, val); \
2845 }
2846
2847
2848
2849 #define PYCALLBACK_INT__pure(CBNAME) \
2850 int CBNAME() { \
2851 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2852 int rval = 0; \
2853 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2854 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2855 wxPyEndBlockThreads(blocked); \
2856 return rval; \
2857 }
2858
2859
2860
2861 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2862 bool CBNAME(int a, int b) { \
2863 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2864 bool rval = 0; \
2865 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2866 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2867 wxPyEndBlockThreads(blocked); \
2868 return rval; \
2869 }
2870
2871
2872 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2873 wxString CBNAME(int a, int b) { \
2874 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2875 wxString rval; \
2876 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2877 PyObject* ro; \
2878 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2879 if (ro) { \
2880 rval = Py2wxString(ro); \
2881 Py_DECREF(ro); \
2882 } \
2883 } \
2884 wxPyEndBlockThreads(blocked); \
2885 return rval; \
2886 }
2887
2888
2889 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2890 void CBNAME(int a, int b, const wxString& c) { \
2891 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2892 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2893 PyObject* s = wx2PyString(c); \
2894 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2895 Py_DECREF(s); \
2896 } \
2897 wxPyEndBlockThreads(blocked); \
2898 }
2899
2900
2901 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2902 wxString CBNAME(int a, int b) { \
2903 bool found; \
2904 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2905 wxString rval; \
2906 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2907 PyObject* ro; \
2908 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2909 if (ro) { \
2910 rval = Py2wxString(ro); \
2911 Py_DECREF(ro); \
2912 } \
2913 } \
2914 wxPyEndBlockThreads(blocked); \
2915 if (! found) \
2916 rval = PCLASS::CBNAME(a, b); \
2917 return rval; \
2918 }
2919
2920
2921 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2922 bool CBNAME(int a, int b, const wxString& c) { \
2923 bool rval = 0; \
2924 bool found; \
2925 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2926 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2927 PyObject* s = wx2PyString(c); \
2928 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2929 Py_DECREF(s); \
2930 } \
2931 wxPyEndBlockThreads(blocked); \
2932 if (! found) \
2933 rval = PCLASS::CBNAME(a,b,c); \
2934 return rval; \
2935 }
2936
2937
2938
2939
2940 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2941 long CBNAME(int a, int b) { \
2942 long rval; \
2943 bool found; \
2944 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2945 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2946 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2947 wxPyEndBlockThreads(blocked); \
2948 if (! found) \
2949 rval = PCLASS::CBNAME(a,b); \
2950 return rval; \
2951 }
2952
2953
2954 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2955 bool CBNAME(int a, int b) { \
2956 bool rval = 0; \
2957 bool found; \
2958 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2959 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2960 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2961 wxPyEndBlockThreads(blocked); \
2962 if (! found) \
2963 rval = PCLASS::CBNAME(a,b); \
2964 return rval; \
2965 }
2966
2967
2968
2969 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2970 double CBNAME(int a, int b) { \
2971 bool found; \
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2973 double rval; \
2974 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2975 PyObject* ro; \
2976 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2977 if (ro) { \
2978 PyObject* str = PyObject_Str(ro); \
2979 rval = PyFloat_AsDouble(str); \
2980 Py_DECREF(ro); Py_DECREF(str); \
2981 } \
2982 } \
2983 wxPyEndBlockThreads(blocked); \
2984 if (! found) \
2985 rval = PCLASS::CBNAME(a, b); \
2986 return rval; \
2987 }
2988
2989
2990
2991 #define PYCALLBACK__(PCLASS, CBNAME) \
2992 void CBNAME() { \
2993 bool found; \
2994 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2995 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2996 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2997 wxPyEndBlockThreads(blocked); \
2998 if (! found) \
2999 PCLASS::CBNAME(); \
3000 }
3001
3002
3003
3004 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3005 bool CBNAME(size_t a, size_t b) { \
3006 bool rval = 0; \
3007 bool found; \
3008 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3009 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3010 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3011 wxPyEndBlockThreads(blocked); \
3012 if (! found) \
3013 rval = PCLASS::CBNAME(a,b); \
3014 return rval; \
3015 }
3016
3017
3018
3019 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3020 bool CBNAME(size_t a) { \
3021 bool rval = 0; \
3022 bool found; \
3023 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3024 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3025 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3026 wxPyEndBlockThreads(blocked); \
3027 if (! found) \
3028 rval = PCLASS::CBNAME(a); \
3029 return rval; \
3030 }
3031
3032
3033 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3034 wxString CBNAME(int a) { \
3035 bool found; \
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3037 wxString rval; \
3038 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3039 PyObject* ro; \
3040 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3041 if (ro) { \
3042 rval = Py2wxString(ro); \
3043 Py_DECREF(ro); \
3044 } \
3045 } \
3046 wxPyEndBlockThreads(blocked); \
3047 if (! found) \
3048 rval = PCLASS::CBNAME(a); \
3049 return rval; \
3050 }
3051
3052
3053 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3054 void CBNAME(int a, const wxString& c) { \
3055 bool found; \
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3057 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3058 PyObject* s = wx2PyString(c); \
3059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3060 Py_DECREF(s); \
3061 } \
3062 wxPyEndBlockThreads(blocked); \
3063 if (! found) \
3064 PCLASS::CBNAME(a,c); \
3065 }
3066
3067
3068
3069
3070 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3071 bool CBNAME() { \
3072 bool rval = 0; \
3073 bool found; \
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3075 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3076 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3077 wxPyEndBlockThreads(blocked); \
3078 if (! found) \
3079 rval = PCLASS::CBNAME(); \
3080 return rval; \
3081 }
3082
3083
3084
3085 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3086 void CBNAME(size_t a, int b) { \
3087 bool found; \
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3089 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3090 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3091 wxPyEndBlockThreads(blocked); \
3092 if (! found) \
3093 PCLASS::CBNAME(a,b); \
3094 }
3095
3096
3097
3098
3099 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3100 void CBNAME(int a, int b, long c) { \
3101 bool found; \
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3103 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3104 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3105 wxPyEndBlockThreads(blocked); \
3106 if (! found) \
3107 PCLASS::CBNAME(a,b,c); \
3108 }
3109
3110
3111
3112
3113 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3114 void CBNAME(int a, int b, double c) { \
3115 bool found; \
3116 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3117 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3118 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3119 wxPyEndBlockThreads(blocked); \
3120 if (! found) \
3121 PCLASS::CBNAME(a,b,c); \
3122 }
3123
3124
3125
3126 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3127 void CBNAME(int a, int b, bool c) { \
3128 bool found; \
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3130 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3131 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3132 wxPyEndBlockThreads(blocked); \
3133 if (! found) \
3134 PCLASS::CBNAME(a,b,c); \
3135 }
3136
3137
3138
3139
3140
3141 SWIGINTERN swig_type_info*
3142 SWIG_pchar_descriptor()
3143 {
3144 static int init = 0;
3145 static swig_type_info* info = 0;
3146 if (!init) {
3147 info = SWIG_TypeQuery("_p_char");
3148 init = 1;
3149 }
3150 return info;
3151 }
3152
3153
3154 SWIGINTERNINLINE PyObject *
3155 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3156 {
3157 if (carray) {
3158 if (size > INT_MAX) {
3159 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3160 return pchar_descriptor ?
3161 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3162 } else {
3163 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3164 }
3165 } else {
3166 return SWIG_Py_Void();
3167 }
3168 }
3169
3170
3171 SWIGINTERNINLINE PyObject *
3172 SWIG_FromCharPtr(const char *cptr)
3173 {
3174 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3175 }
3176
3177
3178 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3179 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3180 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3181 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3182 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3183 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3184 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3185 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3186 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3187 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3188
3189
3190 #define SWIG_From_long PyInt_FromLong
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_From_int (int value)
3195 {
3196 return SWIG_From_long (value);
3197 }
3198
3199 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3200 if (!self->GetClientObject())
3201 self->SetClientObject(new wxPyOORClientData(_self));
3202 }
3203 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3204 }
3205
3206 class wxPyGridCellRenderer : public wxGridCellRenderer
3207 {
3208 public:
3209 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3210
3211 // Implement Python callback aware virtual methods
3212 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3213 wxDC& dc, const wxRect& rect,
3214 int row, int col, bool isSelected) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3217 PyObject* go = wxPyMake_wxObject(&grid,false);
3218 PyObject* dco = wxPyMake_wxObject(&dc,false);
3219 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3220 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3221
3222 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3223 row, col, isSelected));
3224 Py_DECREF(go);
3225 Py_DECREF(ao);
3226 Py_DECREF(dco);
3227 Py_DECREF(ro);
3228 }
3229 wxPyEndBlockThreads(blocked);
3230 }
3231
3232 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3233 int row, int col) {
3234 wxSize rval;
3235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3236 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3237 PyObject* ro;
3238 wxSize* ptr;
3239 PyObject* go = wxPyMake_wxObject(&grid,false);
3240 PyObject* dco = wxPyMake_wxObject(&dc,false);
3241 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3242
3243 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3244 go, ao, dco,
3245 row, col));
3246 Py_DECREF(go);
3247 Py_DECREF(ao);
3248 Py_DECREF(dco);
3249
3250 if (ro) {
3251 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3252 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3253 rval = *ptr;
3254 }
3255 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3256 PyObject* o1 = PySequence_GetItem(ro, 0);
3257 PyObject* o2 = PySequence_GetItem(ro, 1);
3258 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3259 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3260 else
3261 PyErr_SetString(PyExc_TypeError, errmsg);
3262 Py_DECREF(o1);
3263 Py_DECREF(o2);
3264 }
3265 else {
3266 PyErr_SetString(PyExc_TypeError, errmsg);
3267 }
3268 Py_DECREF(ro);
3269 }
3270 }
3271 wxPyEndBlockThreads(blocked);
3272 return rval;
3273 }
3274
3275
3276 wxGridCellRenderer *Clone() const {
3277 wxGridCellRenderer* rval = NULL;
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3280 PyObject* ro;
3281 wxGridCellRenderer* ptr;
3282 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3283 if (ro) {
3284 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3285 rval = ptr;
3286 Py_DECREF(ro);
3287 }
3288 }
3289 wxPyEndBlockThreads(blocked);
3290 return rval;
3291 }
3292
3293 DEC_PYCALLBACK__STRING(SetParameters);
3294
3295 PYPRIVATE;
3296 };
3297
3298 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3299
3300
3301
3302 #include <limits.h>
3303 #ifndef LLONG_MIN
3304 # define LLONG_MIN LONG_LONG_MIN
3305 #endif
3306 #ifndef LLONG_MAX
3307 # define LLONG_MAX LONG_LONG_MAX
3308 #endif
3309 #ifndef ULLONG_MAX
3310 # define ULLONG_MAX ULONG_LONG_MAX
3311 #endif
3312
3313
3314 SWIGINTERN int
3315 SWIG_AsVal_long (PyObject* obj, long* val)
3316 {
3317 if (PyNumber_Check(obj)) {
3318 if (val) *val = PyInt_AsLong(obj);
3319 return SWIG_OK;
3320 }
3321 return SWIG_TypeError;
3322 }
3323
3324
3325 SWIGINTERN int
3326 SWIG_AsVal_int (PyObject * obj, int *val)
3327 {
3328 long v;
3329 int res = SWIG_AsVal_long (obj, &v);
3330 if (SWIG_IsOK(res)) {
3331 if ((v < INT_MIN || v > INT_MAX)) {
3332 return SWIG_OverflowError;
3333 } else {
3334 if (val) *val = static_cast< int >(v);
3335 }
3336 }
3337 return res;
3338 }
3339
3340
3341 SWIGINTERN int
3342 SWIG_AsVal_bool (PyObject *obj, bool *val)
3343 {
3344 if (obj == Py_True) {
3345 if (val) *val = true;
3346 return SWIG_OK;
3347 } else if (obj == Py_False) {
3348 if (val) *val = false;
3349 return SWIG_OK;
3350 } else {
3351 long v = 0;
3352 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3353 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3354 return res;
3355 }
3356 }
3357
3358
3359 class wxPyGridCellEditor : public wxGridCellEditor
3360 {
3361 public:
3362 wxPyGridCellEditor() : wxGridCellEditor() {}
3363
3364 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3365 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3366 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3367 PyObject* po = wxPyMake_wxObject(parent,false);
3368 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3369
3370 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3371 Py_DECREF(po);
3372 Py_DECREF(eo);
3373 }
3374 wxPyEndBlockThreads(blocked);
3375 }
3376
3377
3378 void BeginEdit(int row, int col, wxGrid* grid) {
3379 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3380 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3381 PyObject* go = wxPyMake_wxObject(grid,false);
3382 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3383 Py_DECREF(go);
3384 }
3385 wxPyEndBlockThreads(blocked);
3386 }
3387
3388
3389 bool EndEdit(int row, int col, wxGrid* grid) {
3390 bool rv = false;
3391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3392 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3393 PyObject* go = wxPyMake_wxObject(grid,false);
3394 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3395 Py_DECREF(go);
3396 }
3397 wxPyEndBlockThreads(blocked);
3398 return rv;
3399 }
3400
3401
3402 wxGridCellEditor* Clone() const {
3403 wxGridCellEditor* rval = NULL;
3404 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3405 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3406 PyObject* ro;
3407 wxGridCellEditor* ptr;
3408 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3409 if (ro) {
3410 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3411 rval = ptr;
3412 Py_DECREF(ro);
3413 }
3414 }
3415 wxPyEndBlockThreads(blocked);
3416 return rval;
3417 }
3418
3419
3420 void Show(bool show, wxGridCellAttr *attr) {
3421 bool found;
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3424 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3425 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3426 Py_DECREF(ao);
3427 }
3428 wxPyEndBlockThreads(blocked);
3429 if (! found)
3430 wxGridCellEditor::Show(show, attr);
3431 }
3432
3433
3434 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3435 bool found;
3436 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3437 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3438 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3439 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3440
3441 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3442
3443 Py_DECREF(ro);
3444 Py_DECREF(ao);
3445 }
3446 wxPyEndBlockThreads(blocked);
3447 if (! found)
3448 wxGridCellEditor::PaintBackground(rectCell, attr);
3449 }
3450
3451
3452 DEC_PYCALLBACK___pure(Reset);
3453 DEC_PYCALLBACK__constany(SetSize, wxRect);
3454 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3455 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3456 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3457 DEC_PYCALLBACK__(StartingClick);
3458 DEC_PYCALLBACK__(Destroy);
3459 DEC_PYCALLBACK__STRING(SetParameters);
3460 DEC_PYCALLBACK_STRING__constpure(GetValue);
3461
3462 PYPRIVATE;
3463 };
3464
3465
3466 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3467 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3468 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3469 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3470 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3471 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3472 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3473 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3474 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3475
3476
3477 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3478 if (!self->GetClientObject())
3479 self->SetClientObject(new wxPyOORClientData(_self));
3480 }
3481 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3482 }
3483 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3484 if (!self->GetClientObject())
3485 self->SetClientObject(new wxPyOORClientData(_self));
3486 }
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3490 {
3491 long v = 0;
3492 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3493 return SWIG_TypeError;
3494 }
3495 else if (val)
3496 *val = (unsigned long)v;
3497 return SWIG_OK;
3498 }
3499
3500
3501 SWIGINTERNINLINE int
3502 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3503 {
3504 unsigned long v;
3505 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3506 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3507 return res;
3508 }
3509
3510
3511 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3512 {
3513 public:
3514 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3515
3516 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3517 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3518 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3519 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3520
3521 PYPRIVATE;
3522 };
3523
3524 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3525 if (!self->GetClientObject())
3526 self->SetClientObject(new wxPyOORClientData(_self));
3527 }
3528
3529 #define SWIG_From_double PyFloat_FromDouble
3530
3531
3532 SWIGINTERN int
3533 SWIG_AsVal_double (PyObject *obj, double* val)
3534 {
3535 if (PyNumber_Check(obj)) {
3536 if (val) *val = PyFloat_AsDouble(obj);
3537 return SWIG_OK;
3538 }
3539 return SWIG_TypeError;
3540 }
3541
3542
3543 class wxPyGridTableBase : public wxGridTableBase
3544 {
3545 public:
3546 wxPyGridTableBase() : wxGridTableBase() {}
3547
3548 PYCALLBACK_INT__pure(GetNumberRows);
3549 PYCALLBACK_INT__pure(GetNumberCols);
3550 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3551 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3552 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3553 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3554 PYCALLBACK__(wxGridTableBase, Clear);
3555 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3556 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3557 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3558 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3559 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3560 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3561 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3562 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3563 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3564 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3565 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3566 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3567 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3568 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3569 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3570
3571
3572 wxString GetValue(int row, int col) {
3573 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3574 wxString rval;
3575 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3576 PyObject* ro;
3577 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3578 if (ro) {
3579 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3580 PyObject* old = ro;
3581 ro = PyObject_Str(ro);
3582 Py_DECREF(old);
3583 }
3584 rval = Py2wxString(ro);
3585 Py_DECREF(ro);
3586 }
3587 }
3588 wxPyEndBlockThreads(blocked);
3589 return rval;
3590 }
3591
3592 void SetValue(int row, int col, const wxString& val) {
3593 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3594 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3595 PyObject* s = wx2PyString(val);
3596 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3597 Py_DECREF(s);
3598 }
3599 wxPyEndBlockThreads(blocked);
3600 }
3601
3602
3603 // Map the Get/Set methods for the standard non-string types to
3604 // the GetValue and SetValue python methods.
3605 long GetValueAsLong( int row, int col ) {
3606 long rval = 0;
3607 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3608 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3609 PyObject* ro;
3610 PyObject* num;
3611 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3612 if (ro && PyNumber_Check(ro)) {
3613 num = PyNumber_Int(ro);
3614 if (num) {
3615 rval = PyInt_AsLong(num);
3616 Py_DECREF(num);
3617 }
3618 Py_DECREF(ro);
3619 }
3620 }
3621 wxPyEndBlockThreads(blocked);
3622 return rval;
3623 }
3624
3625 double GetValueAsDouble( int row, int col ) {
3626 double rval = 0.0;
3627 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3628 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3629 PyObject* ro;
3630 PyObject* num;
3631 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3632 if (ro && PyNumber_Check(ro)) {
3633 num = PyNumber_Float(ro);
3634 if (num) {
3635 rval = PyFloat_AsDouble(num);
3636 Py_DECREF(num);
3637 }
3638 Py_DECREF(ro);
3639 }
3640 }
3641 wxPyEndBlockThreads(blocked);
3642 return rval;
3643 }
3644
3645 bool GetValueAsBool( int row, int col ) {
3646 return (bool)GetValueAsLong(row, col);
3647 }
3648
3649 void SetValueAsLong( int row, int col, long value ) {
3650 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3651 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3652 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3653 }
3654 wxPyEndBlockThreads(blocked);
3655 }
3656
3657 void SetValueAsDouble( int row, int col, double value ) {
3658 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3659 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3660 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3661 }
3662 wxPyEndBlockThreads(blocked);
3663 }
3664
3665 void SetValueAsBool( int row, int col, bool value ) {
3666 SetValueAsLong( row, col, (long)value );
3667 }
3668
3669
3670 PYPRIVATE;
3671 };
3672
3673 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3674
3675 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3676
3677 if (source == Py_None) {
3678 **obj = wxGridCellCoords(-1,-1);
3679 return true;
3680 }
3681
3682 // If source is an object instance then it may already be the right type
3683 if (wxPySwigInstance_Check(source)) {
3684 wxGridCellCoords* ptr;
3685 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3686 goto error;
3687 *obj = ptr;
3688 return true;
3689 }
3690 // otherwise a 2-tuple of integers is expected
3691 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3692 PyObject* o1 = PySequence_GetItem(source, 0);
3693 PyObject* o2 = PySequence_GetItem(source, 1);
3694 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3695 Py_DECREF(o1);
3696 Py_DECREF(o2);
3697 goto error;
3698 }
3699 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3700 Py_DECREF(o1);
3701 Py_DECREF(o2);
3702 return true;
3703 }
3704
3705 error:
3706 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3707 return false;
3708 }
3709
3710
3711 bool wxGridCellCoords_typecheck(PyObject* source) {
3712 void* ptr;
3713
3714 if (wxPySwigInstance_Check(source) &&
3715 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3716 return true;
3717
3718 PyErr_Clear();
3719 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3720 return true;
3721
3722 return false;
3723 }
3724
3725
3726 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3727 {
3728 PyObject* list = PyList_New(0);
3729 size_t idx;
3730 for (idx = 0; idx < source.GetCount(); idx += 1) {
3731 wxGridCellCoords& coord = source.Item(idx);
3732 PyObject* tup = PyTuple_New(2);
3733 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3734 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3735 PyList_Append(list, tup);
3736 Py_DECREF(tup);
3737 }
3738 return list;
3739 }
3740
3741 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3742 wxGridCellCoords temp, *obj = &temp;
3743 if ( other == Py_None ) return false;
3744 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3745 PyErr_Clear();
3746 return false;
3747 }
3748 return self->operator==(*obj);
3749 }
3750 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3751 wxGridCellCoords temp, *obj = &temp;
3752 if ( other == Py_None ) return true;
3753 if ( ! wxGridCellCoords_helper(other, &obj)) {
3754 PyErr_Clear();
3755 return true;
3756 }
3757 return self->operator!=(*obj);
3758 }
3759 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3760 PyObject* tup = PyTuple_New(2);
3761 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3762 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3763 return tup;
3764 }
3765
3766 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3767
3768 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3769 wxGridCellCoords rv;
3770 self->XYToCell(x, y, rv);
3771 return rv;
3772 }
3773 #ifdef __cplusplus
3774 extern "C" {
3775 #endif
3776 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3777 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3778 return 1;
3779 }
3780
3781
3782 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3783 PyObject *pyobj = 0;
3784
3785 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3786 return pyobj;
3787 }
3788
3789
3790 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3791 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3792 return 1;
3793 }
3794
3795
3796 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3797 PyObject *pyobj = 0;
3798
3799 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3800 return pyobj;
3801 }
3802
3803
3804 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3805 PyObject *resultobj = 0;
3806 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3807 PyObject *arg2 = (PyObject *) 0 ;
3808 void *argp1 = 0 ;
3809 int res1 = 0 ;
3810 PyObject * obj0 = 0 ;
3811 PyObject * obj1 = 0 ;
3812 char * kwnames[] = {
3813 (char *) "self",(char *) "_self", NULL
3814 };
3815
3816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3818 if (!SWIG_IsOK(res1)) {
3819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3820 }
3821 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3822 arg2 = obj1;
3823 {
3824 PyThreadState* __tstate = wxPyBeginAllowThreads();
3825 wxGridCellWorker__setOORInfo(arg1,arg2);
3826 wxPyEndAllowThreads(__tstate);
3827 if (PyErr_Occurred()) SWIG_fail;
3828 }
3829 resultobj = SWIG_Py_Void();
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3837 PyObject *resultobj = 0;
3838 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3839 void *argp1 = 0 ;
3840 int res1 = 0 ;
3841 PyObject *swig_obj[1] ;
3842
3843 if (!args) SWIG_fail;
3844 swig_obj[0] = args;
3845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3846 if (!SWIG_IsOK(res1)) {
3847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3848 }
3849 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3850 {
3851 PyThreadState* __tstate = wxPyBeginAllowThreads();
3852 delete_wxGridCellWorker(arg1);
3853
3854 wxPyEndAllowThreads(__tstate);
3855 if (PyErr_Occurred()) SWIG_fail;
3856 }
3857 resultobj = SWIG_Py_Void();
3858 return resultobj;
3859 fail:
3860 return NULL;
3861 }
3862
3863
3864 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3865 PyObject *resultobj = 0;
3866 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3867 wxString *arg2 = 0 ;
3868 void *argp1 = 0 ;
3869 int res1 = 0 ;
3870 bool temp2 = false ;
3871 PyObject * obj0 = 0 ;
3872 PyObject * obj1 = 0 ;
3873 char * kwnames[] = {
3874 (char *) "self",(char *) "params", NULL
3875 };
3876
3877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3879 if (!SWIG_IsOK(res1)) {
3880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3881 }
3882 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3883 {
3884 arg2 = wxString_in_helper(obj1);
3885 if (arg2 == NULL) SWIG_fail;
3886 temp2 = true;
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 (arg1)->SetParameters((wxString const &)*arg2);
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 resultobj = SWIG_Py_Void();
3895 {
3896 if (temp2)
3897 delete arg2;
3898 }
3899 return resultobj;
3900 fail:
3901 {
3902 if (temp2)
3903 delete arg2;
3904 }
3905 return NULL;
3906 }
3907
3908
3909 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3910 PyObject *resultobj = 0;
3911 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3912 void *argp1 = 0 ;
3913 int res1 = 0 ;
3914 PyObject *swig_obj[1] ;
3915
3916 if (!args) SWIG_fail;
3917 swig_obj[0] = args;
3918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3919 if (!SWIG_IsOK(res1)) {
3920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3921 }
3922 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3923 {
3924 PyThreadState* __tstate = wxPyBeginAllowThreads();
3925 (arg1)->IncRef();
3926 wxPyEndAllowThreads(__tstate);
3927 if (PyErr_Occurred()) SWIG_fail;
3928 }
3929 resultobj = SWIG_Py_Void();
3930 return resultobj;
3931 fail:
3932 return NULL;
3933 }
3934
3935
3936 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3937 PyObject *resultobj = 0;
3938 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3939 void *argp1 = 0 ;
3940 int res1 = 0 ;
3941 PyObject *swig_obj[1] ;
3942
3943 if (!args) SWIG_fail;
3944 swig_obj[0] = args;
3945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3946 if (!SWIG_IsOK(res1)) {
3947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3948 }
3949 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3950 {
3951 PyThreadState* __tstate = wxPyBeginAllowThreads();
3952 (arg1)->DecRef();
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 resultobj = SWIG_Py_Void();
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3964 PyObject *obj;
3965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3966 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3967 return SWIG_Py_Void();
3968 }
3969
3970 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3971 PyObject *obj;
3972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3973 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3974 return SWIG_Py_Void();
3975 }
3976
3977 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3978 PyObject *resultobj = 0;
3979 wxPyGridCellRenderer *result = 0 ;
3980
3981 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3982 {
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj = 0;
3997 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3998 PyObject *arg2 = (PyObject *) 0 ;
3999 PyObject *arg3 = (PyObject *) 0 ;
4000 void *argp1 = 0 ;
4001 int res1 = 0 ;
4002 PyObject * obj0 = 0 ;
4003 PyObject * obj1 = 0 ;
4004 PyObject * obj2 = 0 ;
4005 char * kwnames[] = {
4006 (char *) "self",(char *) "self",(char *) "_class", NULL
4007 };
4008
4009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4011 if (!SWIG_IsOK(res1)) {
4012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4013 }
4014 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4015 arg2 = obj1;
4016 arg3 = obj2;
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 (arg1)->_setCallbackInfo(arg2,arg3);
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 resultobj = SWIG_Py_Void();
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj = 0;
4032 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4033 wxString *arg2 = 0 ;
4034 void *argp1 = 0 ;
4035 int res1 = 0 ;
4036 bool temp2 = false ;
4037 PyObject * obj0 = 0 ;
4038 PyObject * obj1 = 0 ;
4039 char * kwnames[] = {
4040 (char *) "self",(char *) "params", NULL
4041 };
4042
4043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4045 if (!SWIG_IsOK(res1)) {
4046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4047 }
4048 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4049 {
4050 arg2 = wxString_in_helper(obj1);
4051 if (arg2 == NULL) SWIG_fail;
4052 temp2 = true;
4053 }
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 (arg1)->SetParameters((wxString const &)*arg2);
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 resultobj = SWIG_Py_Void();
4061 {
4062 if (temp2)
4063 delete arg2;
4064 }
4065 return resultobj;
4066 fail:
4067 {
4068 if (temp2)
4069 delete arg2;
4070 }
4071 return NULL;
4072 }
4073
4074
4075 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4076 PyObject *obj;
4077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4079 return SWIG_Py_Void();
4080 }
4081
4082 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4083 return SWIG_Python_InitShadowInstance(args);
4084 }
4085
4086 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4087 PyObject *resultobj = 0;
4088 wxGridCellStringRenderer *result = 0 ;
4089
4090 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4091 {
4092 PyThreadState* __tstate = wxPyBeginAllowThreads();
4093 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4105 PyObject *obj;
4106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4107 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4108 return SWIG_Py_Void();
4109 }
4110
4111 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4112 return SWIG_Python_InitShadowInstance(args);
4113 }
4114
4115 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4116 PyObject *resultobj = 0;
4117 wxGridCellNumberRenderer *result = 0 ;
4118
4119 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4120 {
4121 PyThreadState* __tstate = wxPyBeginAllowThreads();
4122 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4127 return resultobj;
4128 fail:
4129 return NULL;
4130 }
4131
4132
4133 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4134 PyObject *obj;
4135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4137 return SWIG_Py_Void();
4138 }
4139
4140 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4141 return SWIG_Python_InitShadowInstance(args);
4142 }
4143
4144 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = 0;
4146 int arg1 = (int) -1 ;
4147 int arg2 = (int) -1 ;
4148 wxGridCellFloatRenderer *result = 0 ;
4149 int val1 ;
4150 int ecode1 = 0 ;
4151 int val2 ;
4152 int ecode2 = 0 ;
4153 PyObject * obj0 = 0 ;
4154 PyObject * obj1 = 0 ;
4155 char * kwnames[] = {
4156 (char *) "width",(char *) "precision", NULL
4157 };
4158
4159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4160 if (obj0) {
4161 ecode1 = SWIG_AsVal_int(obj0, &val1);
4162 if (!SWIG_IsOK(ecode1)) {
4163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4164 }
4165 arg1 = static_cast< int >(val1);
4166 }
4167 if (obj1) {
4168 ecode2 = SWIG_AsVal_int(obj1, &val2);
4169 if (!SWIG_IsOK(ecode2)) {
4170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4171 }
4172 arg2 = static_cast< int >(val2);
4173 }
4174 {
4175 PyThreadState* __tstate = wxPyBeginAllowThreads();
4176 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4188 PyObject *resultobj = 0;
4189 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4190 int result;
4191 void *argp1 = 0 ;
4192 int res1 = 0 ;
4193 PyObject *swig_obj[1] ;
4194
4195 if (!args) SWIG_fail;
4196 swig_obj[0] = args;
4197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4198 if (!SWIG_IsOK(res1)) {
4199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4200 }
4201 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4205 wxPyEndAllowThreads(__tstate);
4206 if (PyErr_Occurred()) SWIG_fail;
4207 }
4208 resultobj = SWIG_From_int(static_cast< int >(result));
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4216 PyObject *resultobj = 0;
4217 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4218 int arg2 ;
4219 void *argp1 = 0 ;
4220 int res1 = 0 ;
4221 int val2 ;
4222 int ecode2 = 0 ;
4223 PyObject * obj0 = 0 ;
4224 PyObject * obj1 = 0 ;
4225 char * kwnames[] = {
4226 (char *) "self",(char *) "width", NULL
4227 };
4228
4229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4231 if (!SWIG_IsOK(res1)) {
4232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4233 }
4234 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4235 ecode2 = SWIG_AsVal_int(obj1, &val2);
4236 if (!SWIG_IsOK(ecode2)) {
4237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4238 }
4239 arg2 = static_cast< int >(val2);
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 (arg1)->SetWidth(arg2);
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 resultobj = SWIG_Py_Void();
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254 PyObject *resultobj = 0;
4255 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4256 int result;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 PyObject *swig_obj[1] ;
4260
4261 if (!args) SWIG_fail;
4262 swig_obj[0] = args;
4263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4264 if (!SWIG_IsOK(res1)) {
4265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4266 }
4267 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 resultobj = SWIG_From_int(static_cast< int >(result));
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj = 0;
4283 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4284 int arg2 ;
4285 void *argp1 = 0 ;
4286 int res1 = 0 ;
4287 int val2 ;
4288 int ecode2 = 0 ;
4289 PyObject * obj0 = 0 ;
4290 PyObject * obj1 = 0 ;
4291 char * kwnames[] = {
4292 (char *) "self",(char *) "precision", NULL
4293 };
4294
4295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4299 }
4300 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4301 ecode2 = SWIG_AsVal_int(obj1, &val2);
4302 if (!SWIG_IsOK(ecode2)) {
4303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4304 }
4305 arg2 = static_cast< int >(val2);
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 (arg1)->SetPrecision(arg2);
4309 wxPyEndAllowThreads(__tstate);
4310 if (PyErr_Occurred()) SWIG_fail;
4311 }
4312 resultobj = SWIG_Py_Void();
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4320 PyObject *obj;
4321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4322 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4323 return SWIG_Py_Void();
4324 }
4325
4326 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4327 return SWIG_Python_InitShadowInstance(args);
4328 }
4329
4330 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 PyObject *resultobj = 0;
4332 wxGridCellBoolRenderer *result = 0 ;
4333
4334 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4338 wxPyEndAllowThreads(__tstate);
4339 if (PyErr_Occurred()) SWIG_fail;
4340 }
4341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4342 return resultobj;
4343 fail:
4344 return NULL;
4345 }
4346
4347
4348 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4349 PyObject *obj;
4350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4351 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4352 return SWIG_Py_Void();
4353 }
4354
4355 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4356 return SWIG_Python_InitShadowInstance(args);
4357 }
4358
4359 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj = 0;
4361 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4362 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4363 wxGridCellDateTimeRenderer *result = 0 ;
4364 PyObject * obj0 = 0 ;
4365 PyObject * obj1 = 0 ;
4366 char * kwnames[] = {
4367 (char *) "outformat",(char *) "informat", NULL
4368 };
4369
4370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4371 if (obj0) {
4372 {
4373 wxString* sptr = wxString_in_helper(obj0);
4374 if (sptr == NULL) SWIG_fail;
4375 arg1 = *sptr;
4376 delete sptr;
4377 }
4378 }
4379 if (obj1) {
4380 {
4381 wxString* sptr = wxString_in_helper(obj1);
4382 if (sptr == NULL) SWIG_fail;
4383 arg2 = *sptr;
4384 delete sptr;
4385 }
4386 }
4387 {
4388 PyThreadState* __tstate = wxPyBeginAllowThreads();
4389 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4390 wxPyEndAllowThreads(__tstate);
4391 if (PyErr_Occurred()) SWIG_fail;
4392 }
4393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4401 PyObject *obj;
4402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4403 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4404 return SWIG_Py_Void();
4405 }
4406
4407 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408 return SWIG_Python_InitShadowInstance(args);
4409 }
4410
4411 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj = 0;
4413 wxString const &arg1_defvalue = wxPyEmptyString ;
4414 wxString *arg1 = (wxString *) &arg1_defvalue ;
4415 wxGridCellEnumRenderer *result = 0 ;
4416 bool temp1 = false ;
4417 PyObject * obj0 = 0 ;
4418 char * kwnames[] = {
4419 (char *) "choices", NULL
4420 };
4421
4422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4423 if (obj0) {
4424 {
4425 arg1 = wxString_in_helper(obj0);
4426 if (arg1 == NULL) SWIG_fail;
4427 temp1 = true;
4428 }
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4437 {
4438 if (temp1)
4439 delete arg1;
4440 }
4441 return resultobj;
4442 fail:
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return NULL;
4448 }
4449
4450
4451 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4452 PyObject *obj;
4453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4454 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4455 return SWIG_Py_Void();
4456 }
4457
4458 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 return SWIG_Python_InitShadowInstance(args);
4460 }
4461
4462 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxGridCellAutoWrapStringRenderer *result = 0 ;
4465
4466 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *obj;
4482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4483 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4484 return SWIG_Py_Void();
4485 }
4486
4487 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 return SWIG_Python_InitShadowInstance(args);
4489 }
4490
4491 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4494 bool result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4504 }
4505 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 result = (bool)(arg1)->IsCreated();
4509 wxPyEndAllowThreads(__tstate);
4510 if (PyErr_Occurred()) SWIG_fail;
4511 }
4512 {
4513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4514 }
4515 return resultobj;
4516 fail:
4517 return NULL;
4518 }
4519
4520
4521 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4522 PyObject *resultobj = 0;
4523 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4524 wxControl *result = 0 ;
4525 void *argp1 = 0 ;
4526 int res1 = 0 ;
4527 PyObject *swig_obj[1] ;
4528
4529 if (!args) SWIG_fail;
4530 swig_obj[0] = args;
4531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4532 if (!SWIG_IsOK(res1)) {
4533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4534 }
4535 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4536 {
4537 PyThreadState* __tstate = wxPyBeginAllowThreads();
4538 result = (wxControl *)(arg1)->GetControl();
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 resultobj = wxPyMake_wxObject(result, 0);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj = 0;
4553 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4554 wxControl *arg2 = (wxControl *) 0 ;
4555 void *argp1 = 0 ;
4556 int res1 = 0 ;
4557 void *argp2 = 0 ;
4558 int res2 = 0 ;
4559 PyObject * obj0 = 0 ;
4560 PyObject * obj1 = 0 ;
4561 char * kwnames[] = {
4562 (char *) "self",(char *) "control", NULL
4563 };
4564
4565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4567 if (!SWIG_IsOK(res1)) {
4568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4569 }
4570 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4572 if (!SWIG_IsOK(res2)) {
4573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4574 }
4575 arg2 = reinterpret_cast< wxControl * >(argp2);
4576 {
4577 PyThreadState* __tstate = wxPyBeginAllowThreads();
4578 (arg1)->SetControl(arg2);
4579 wxPyEndAllowThreads(__tstate);
4580 if (PyErr_Occurred()) SWIG_fail;
4581 }
4582 resultobj = SWIG_Py_Void();
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4590 PyObject *resultobj = 0;
4591 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4592 wxGridCellAttr *result = 0 ;
4593 void *argp1 = 0 ;
4594 int res1 = 0 ;
4595 PyObject *swig_obj[1] ;
4596
4597 if (!args) SWIG_fail;
4598 swig_obj[0] = args;
4599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4600 if (!SWIG_IsOK(res1)) {
4601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4602 }
4603 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4607 wxPyEndAllowThreads(__tstate);
4608 if (PyErr_Occurred()) SWIG_fail;
4609 }
4610 {
4611 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4612 }
4613 return resultobj;
4614 fail:
4615 return NULL;
4616 }
4617
4618
4619 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4620 PyObject *resultobj = 0;
4621 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4622 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4623 void *argp1 = 0 ;
4624 int res1 = 0 ;
4625 void *argp2 = 0 ;
4626 int res2 = 0 ;
4627 PyObject * obj0 = 0 ;
4628 PyObject * obj1 = 0 ;
4629 char * kwnames[] = {
4630 (char *) "self",(char *) "attr", NULL
4631 };
4632
4633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4635 if (!SWIG_IsOK(res1)) {
4636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4637 }
4638 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4640 if (!SWIG_IsOK(res2)) {
4641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4642 }
4643 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 (arg1)->SetCellAttr(arg2);
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4660 wxWindow *arg2 = (wxWindow *) 0 ;
4661 int arg3 ;
4662 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 void *argp2 = 0 ;
4666 int res2 = 0 ;
4667 int val3 ;
4668 int ecode3 = 0 ;
4669 void *argp4 = 0 ;
4670 int res4 = 0 ;
4671 PyObject * obj0 = 0 ;
4672 PyObject * obj1 = 0 ;
4673 PyObject * obj2 = 0 ;
4674 PyObject * obj3 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4681 if (!SWIG_IsOK(res1)) {
4682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4683 }
4684 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4686 if (!SWIG_IsOK(res2)) {
4687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4688 }
4689 arg2 = reinterpret_cast< wxWindow * >(argp2);
4690 ecode3 = SWIG_AsVal_int(obj2, &val3);
4691 if (!SWIG_IsOK(ecode3)) {
4692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4693 }
4694 arg3 = static_cast< int >(val3);
4695 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4696 if (!SWIG_IsOK(res4)) {
4697 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4698 }
4699 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 (arg1)->Create(arg2,arg3,arg4);
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_Py_Void();
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4716 int arg2 ;
4717 int arg3 ;
4718 wxGrid *arg4 = (wxGrid *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 int val2 ;
4722 int ecode2 = 0 ;
4723 int val3 ;
4724 int ecode3 = 0 ;
4725 void *argp4 = 0 ;
4726 int res4 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 PyObject * obj1 = 0 ;
4729 PyObject * obj2 = 0 ;
4730 PyObject * obj3 = 0 ;
4731 char * kwnames[] = {
4732 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4733 };
4734
4735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4739 }
4740 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4741 ecode2 = SWIG_AsVal_int(obj1, &val2);
4742 if (!SWIG_IsOK(ecode2)) {
4743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4744 }
4745 arg2 = static_cast< int >(val2);
4746 ecode3 = SWIG_AsVal_int(obj2, &val3);
4747 if (!SWIG_IsOK(ecode3)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4749 }
4750 arg3 = static_cast< int >(val3);
4751 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4752 if (!SWIG_IsOK(res4)) {
4753 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4754 }
4755 arg4 = reinterpret_cast< wxGrid * >(argp4);
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 (arg1)->BeginEdit(arg2,arg3,arg4);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = SWIG_Py_Void();
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4770 PyObject *resultobj = 0;
4771 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4772 int arg2 ;
4773 int arg3 ;
4774 wxGrid *arg4 = (wxGrid *) 0 ;
4775 bool result;
4776 void *argp1 = 0 ;
4777 int res1 = 0 ;
4778 int val2 ;
4779 int ecode2 = 0 ;
4780 int val3 ;
4781 int ecode3 = 0 ;
4782 void *argp4 = 0 ;
4783 int res4 = 0 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 PyObject * obj2 = 0 ;
4787 PyObject * obj3 = 0 ;
4788 char * kwnames[] = {
4789 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4790 };
4791
4792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4796 }
4797 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4798 ecode2 = SWIG_AsVal_int(obj1, &val2);
4799 if (!SWIG_IsOK(ecode2)) {
4800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4801 }
4802 arg2 = static_cast< int >(val2);
4803 ecode3 = SWIG_AsVal_int(obj2, &val3);
4804 if (!SWIG_IsOK(ecode3)) {
4805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4806 }
4807 arg3 = static_cast< int >(val3);
4808 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4809 if (!SWIG_IsOK(res4)) {
4810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4811 }
4812 arg4 = reinterpret_cast< wxGrid * >(argp4);
4813 {
4814 PyThreadState* __tstate = wxPyBeginAllowThreads();
4815 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4816 wxPyEndAllowThreads(__tstate);
4817 if (PyErr_Occurred()) SWIG_fail;
4818 }
4819 {
4820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4821 }
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4829 PyObject *resultobj = 0;
4830 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4831 void *argp1 = 0 ;
4832 int res1 = 0 ;
4833 PyObject *swig_obj[1] ;
4834
4835 if (!args) SWIG_fail;
4836 swig_obj[0] = args;
4837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4838 if (!SWIG_IsOK(res1)) {
4839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4840 }
4841 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 (arg1)->Reset();
4845 wxPyEndAllowThreads(__tstate);
4846 if (PyErr_Occurred()) SWIG_fail;
4847 }
4848 resultobj = SWIG_Py_Void();
4849 return resultobj;
4850 fail:
4851 return NULL;
4852 }
4853
4854
4855 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4856 PyObject *resultobj = 0;
4857 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4858 wxGridCellEditor *result = 0 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 PyObject *swig_obj[1] ;
4862
4863 if (!args) SWIG_fail;
4864 swig_obj[0] = args;
4865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4866 if (!SWIG_IsOK(res1)) {
4867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4868 }
4869 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 {
4877 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4878 }
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4888 wxRect *arg2 = 0 ;
4889 void *argp1 = 0 ;
4890 int res1 = 0 ;
4891 wxRect temp2 ;
4892 PyObject * obj0 = 0 ;
4893 PyObject * obj1 = 0 ;
4894 char * kwnames[] = {
4895 (char *) "self",(char *) "rect", NULL
4896 };
4897
4898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4900 if (!SWIG_IsOK(res1)) {
4901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4902 }
4903 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4904 {
4905 arg2 = &temp2;
4906 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 (arg1)->SetSize((wxRect const &)*arg2);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj = 0;
4923 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4924 bool arg2 ;
4925 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4926 void *argp1 = 0 ;
4927 int res1 = 0 ;
4928 bool val2 ;
4929 int ecode2 = 0 ;
4930 void *argp3 = 0 ;
4931 int res3 = 0 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 PyObject * obj2 = 0 ;
4935 char * kwnames[] = {
4936 (char *) "self",(char *) "show",(char *) "attr", NULL
4937 };
4938
4939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4941 if (!SWIG_IsOK(res1)) {
4942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4943 }
4944 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4946 if (!SWIG_IsOK(ecode2)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4948 }
4949 arg2 = static_cast< bool >(val2);
4950 if (obj2) {
4951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4952 if (!SWIG_IsOK(res3)) {
4953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4954 }
4955 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4956 }
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 (arg1)->Show(arg2,arg3);
4960 wxPyEndAllowThreads(__tstate);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 resultobj = SWIG_Py_Void();
4964 return resultobj;
4965 fail:
4966 return NULL;
4967 }
4968
4969
4970 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj = 0;
4972 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4973 wxRect *arg2 = 0 ;
4974 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4975 void *argp1 = 0 ;
4976 int res1 = 0 ;
4977 wxRect temp2 ;
4978 void *argp3 = 0 ;
4979 int res3 = 0 ;
4980 PyObject * obj0 = 0 ;
4981 PyObject * obj1 = 0 ;
4982 PyObject * obj2 = 0 ;
4983 char * kwnames[] = {
4984 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4985 };
4986
4987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4989 if (!SWIG_IsOK(res1)) {
4990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4991 }
4992 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4993 {
4994 arg2 = &temp2;
4995 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4996 }
4997 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4998 if (!SWIG_IsOK(res3)) {
4999 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5000 }
5001 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_Py_Void();
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj = 0;
5017 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5018 wxKeyEvent *arg2 = 0 ;
5019 bool result;
5020 void *argp1 = 0 ;
5021 int res1 = 0 ;
5022 void *argp2 = 0 ;
5023 int res2 = 0 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 char * kwnames[] = {
5027 (char *) "self",(char *) "event", NULL
5028 };
5029
5030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5034 }
5035 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5037 if (!SWIG_IsOK(res2)) {
5038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5039 }
5040 if (!argp2) {
5041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5042 }
5043 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5052 }
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5062 wxKeyEvent *arg2 = 0 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 void *argp2 = 0 ;
5066 int res2 = 0 ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 char * kwnames[] = {
5070 (char *) "self",(char *) "event", NULL
5071 };
5072
5073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5077 }
5078 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5080 if (!SWIG_IsOK(res2)) {
5081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5082 }
5083 if (!argp2) {
5084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5085 }
5086 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 (arg1)->StartingKey(*arg2);
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_Py_Void();
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5103 void *argp1 = 0 ;
5104 int res1 = 0 ;
5105 PyObject *swig_obj[1] ;
5106
5107 if (!args) SWIG_fail;
5108 swig_obj[0] = args;
5109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5110 if (!SWIG_IsOK(res1)) {
5111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5112 }
5113 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5114 {
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 (arg1)->StartingClick();
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_Py_Void();
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj = 0;
5129 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5130 wxKeyEvent *arg2 = 0 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 void *argp2 = 0 ;
5134 int res2 = 0 ;
5135 PyObject * obj0 = 0 ;
5136 PyObject * obj1 = 0 ;
5137 char * kwnames[] = {
5138 (char *) "self",(char *) "event", NULL
5139 };
5140
5141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5143 if (!SWIG_IsOK(res1)) {
5144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5145 }
5146 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5148 if (!SWIG_IsOK(res2)) {
5149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5150 }
5151 if (!argp2) {
5152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5153 }
5154 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 (arg1)->HandleReturn(*arg2);
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5171 void *argp1 = 0 ;
5172 int res1 = 0 ;
5173 PyObject *swig_obj[1] ;
5174
5175 if (!args) SWIG_fail;
5176 swig_obj[0] = args;
5177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5180 }
5181 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->Destroy();
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5196 PyObject *obj;
5197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5199 return SWIG_Py_Void();
5200 }
5201
5202 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *resultobj = 0;
5204 wxPyGridCellEditor *result = 0 ;
5205
5206 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5223 PyObject *arg2 = (PyObject *) 0 ;
5224 PyObject *arg3 = (PyObject *) 0 ;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 PyObject * obj2 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "self",(char *) "_class", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5238 }
5239 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5240 arg2 = obj1;
5241 arg3 = obj2;
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 (arg1)->_setCallbackInfo(arg2,arg3);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_Py_Void();
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj = 0;
5257 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5258 wxString *arg2 = 0 ;
5259 void *argp1 = 0 ;
5260 int res1 = 0 ;
5261 bool temp2 = false ;
5262 PyObject * obj0 = 0 ;
5263 PyObject * obj1 = 0 ;
5264 char * kwnames[] = {
5265 (char *) "self",(char *) "params", NULL
5266 };
5267
5268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5270 if (!SWIG_IsOK(res1)) {
5271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5272 }
5273 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5274 {
5275 arg2 = wxString_in_helper(obj1);
5276 if (arg2 == NULL) SWIG_fail;
5277 temp2 = true;
5278 }
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 (arg1)->SetParameters((wxString const &)*arg2);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 {
5287 if (temp2)
5288 delete arg2;
5289 }
5290 return resultobj;
5291 fail:
5292 {
5293 if (temp2)
5294 delete arg2;
5295 }
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5301 PyObject *obj;
5302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5304 return SWIG_Py_Void();
5305 }
5306
5307 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5308 return SWIG_Python_InitShadowInstance(args);
5309 }
5310
5311 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxGridCellTextEditor *result = 0 ;
5314
5315 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 PyObject *resultobj = 0;
5331 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5332 wxString result;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject *swig_obj[1] ;
5336
5337 if (!args) SWIG_fail;
5338 swig_obj[0] = args;
5339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5342 }
5343 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = (arg1)->GetValue();
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 #if wxUSE_UNICODE
5352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5353 #else
5354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5355 #endif
5356 }
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5364 PyObject *obj;
5365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5367 return SWIG_Py_Void();
5368 }
5369
5370 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5371 return SWIG_Python_InitShadowInstance(args);
5372 }
5373
5374 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj = 0;
5376 int arg1 = (int) -1 ;
5377 int arg2 = (int) -1 ;
5378 wxGridCellNumberEditor *result = 0 ;
5379 int val1 ;
5380 int ecode1 = 0 ;
5381 int val2 ;
5382 int ecode2 = 0 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char * kwnames[] = {
5386 (char *) "min",(char *) "max", NULL
5387 };
5388
5389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5390 if (obj0) {
5391 ecode1 = SWIG_AsVal_int(obj0, &val1);
5392 if (!SWIG_IsOK(ecode1)) {
5393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5394 }
5395 arg1 = static_cast< int >(val1);
5396 }
5397 if (obj1) {
5398 ecode2 = SWIG_AsVal_int(obj1, &val2);
5399 if (!SWIG_IsOK(ecode2)) {
5400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5401 }
5402 arg2 = static_cast< int >(val2);
5403 }
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *obj;
5419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5420 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5421 return SWIG_Py_Void();
5422 }
5423
5424 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 return SWIG_Python_InitShadowInstance(args);
5426 }
5427
5428 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 int arg1 = (int) -1 ;
5431 int arg2 = (int) -1 ;
5432 wxGridCellFloatEditor *result = 0 ;
5433 int val1 ;
5434 int ecode1 = 0 ;
5435 int val2 ;
5436 int ecode2 = 0 ;
5437 PyObject * obj0 = 0 ;
5438 PyObject * obj1 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "width",(char *) "precision", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5444 if (obj0) {
5445 ecode1 = SWIG_AsVal_int(obj0, &val1);
5446 if (!SWIG_IsOK(ecode1)) {
5447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5448 }
5449 arg1 = static_cast< int >(val1);
5450 }
5451 if (obj1) {
5452 ecode2 = SWIG_AsVal_int(obj1, &val2);
5453 if (!SWIG_IsOK(ecode2)) {
5454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5455 }
5456 arg2 = static_cast< int >(val2);
5457 }
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5472 PyObject *obj;
5473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5474 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5475 return SWIG_Py_Void();
5476 }
5477
5478 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 return SWIG_Python_InitShadowInstance(args);
5480 }
5481
5482 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxGridCellBoolEditor *result = 0 ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5503 wxString result;
5504 void *argp1 = 0 ;
5505 int res1 = 0 ;
5506 PyObject *swig_obj[1] ;
5507
5508 if (!args) SWIG_fail;
5509 swig_obj[0] = args;
5510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5511 if (!SWIG_IsOK(res1)) {
5512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5513 }
5514 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5515 {
5516 PyThreadState* __tstate = wxPyBeginAllowThreads();
5517 result = (arg1)->GetValue();
5518 wxPyEndAllowThreads(__tstate);
5519 if (PyErr_Occurred()) SWIG_fail;
5520 }
5521 {
5522 #if wxUSE_UNICODE
5523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5524 #else
5525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5526 #endif
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5535 PyObject *obj;
5536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5537 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5538 return SWIG_Py_Void();
5539 }
5540
5541 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5542 return SWIG_Python_InitShadowInstance(args);
5543 }
5544
5545 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj = 0;
5547 int arg1 = (int) 0 ;
5548 wxString *arg2 = (wxString *) NULL ;
5549 bool arg3 = (bool) false ;
5550 wxGridCellChoiceEditor *result = 0 ;
5551 bool val3 ;
5552 int ecode3 = 0 ;
5553 PyObject * obj0 = 0 ;
5554 PyObject * obj1 = 0 ;
5555 char * kwnames[] = {
5556 (char *) "choices",(char *) "allowOthers", NULL
5557 };
5558
5559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5560 if (obj0) {
5561 {
5562 arg1 = PyList_Size(obj0);
5563 arg2 = wxString_LIST_helper(obj0);
5564 if (arg2 == NULL) SWIG_fail;
5565 }
5566 }
5567 if (obj1) {
5568 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5569 if (!SWIG_IsOK(ecode3)) {
5570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5571 }
5572 arg3 = static_cast< bool >(val3);
5573 }
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5581 {
5582 if (arg2) delete [] arg2;
5583 }
5584 return resultobj;
5585 fail:
5586 {
5587 if (arg2) delete [] arg2;
5588 }
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5596 wxString result;
5597 void *argp1 = 0 ;
5598 int res1 = 0 ;
5599 PyObject *swig_obj[1] ;
5600
5601 if (!args) SWIG_fail;
5602 swig_obj[0] = args;
5603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5606 }
5607 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5608 {
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 result = (arg1)->GetValue();
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 {
5615 #if wxUSE_UNICODE
5616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5617 #else
5618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5619 #endif
5620 }
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5628 PyObject *obj;
5629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5630 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5631 return SWIG_Py_Void();
5632 }
5633
5634 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 return SWIG_Python_InitShadowInstance(args);
5636 }
5637
5638 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj = 0;
5640 wxString const &arg1_defvalue = wxPyEmptyString ;
5641 wxString *arg1 = (wxString *) &arg1_defvalue ;
5642 wxGridCellEnumEditor *result = 0 ;
5643 bool temp1 = false ;
5644 PyObject * obj0 = 0 ;
5645 char * kwnames[] = {
5646 (char *) "choices", NULL
5647 };
5648
5649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5650 if (obj0) {
5651 {
5652 arg1 = wxString_in_helper(obj0);
5653 if (arg1 == NULL) SWIG_fail;
5654 temp1 = true;
5655 }
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5664 {
5665 if (temp1)
5666 delete arg1;
5667 }
5668 return resultobj;
5669 fail:
5670 {
5671 if (temp1)
5672 delete arg1;
5673 }
5674 return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679 PyObject *obj;
5680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5681 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5682 return SWIG_Py_Void();
5683 }
5684
5685 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5686 return SWIG_Python_InitShadowInstance(args);
5687 }
5688
5689 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 PyObject *resultobj = 0;
5691 wxGridCellAutoWrapStringEditor *result = 0 ;
5692
5693 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5708 PyObject *obj;
5709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5710 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5711 return SWIG_Py_Void();
5712 }
5713
5714 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 return SWIG_Python_InitShadowInstance(args);
5716 }
5717
5718 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj = 0;
5720 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5721 PyObject *arg2 = (PyObject *) 0 ;
5722 void *argp1 = 0 ;
5723 int res1 = 0 ;
5724 PyObject * obj0 = 0 ;
5725 PyObject * obj1 = 0 ;
5726 char * kwnames[] = {
5727 (char *) "self",(char *) "_self", NULL
5728 };
5729
5730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5732 if (!SWIG_IsOK(res1)) {
5733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5734 }
5735 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5736 arg2 = obj1;
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 wxGridCellAttr__setOORInfo(arg1,arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 resultobj = SWIG_Py_Void();
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = 0;
5752 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5753 wxGridCellAttr *result = 0 ;
5754 void *argp1 = 0 ;
5755 int res1 = 0 ;
5756 PyObject * obj0 = 0 ;
5757 char * kwnames[] = {
5758 (char *) "attrDefault", NULL
5759 };
5760
5761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5762 if (obj0) {
5763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5764 if (!SWIG_IsOK(res1)) {
5765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5766 }
5767 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 {
5776 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5777 }
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5785 PyObject *resultobj = 0;
5786 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject *swig_obj[1] ;
5790
5791 if (!args) SWIG_fail;
5792 swig_obj[0] = args;
5793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5796 }
5797 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 delete_wxGridCellAttr(arg1);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 resultobj = SWIG_Py_Void();
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813 PyObject *resultobj = 0;
5814 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5815 wxGridCellAttr *result = 0 ;
5816 void *argp1 = 0 ;
5817 int res1 = 0 ;
5818 PyObject *swig_obj[1] ;
5819
5820 if (!args) SWIG_fail;
5821 swig_obj[0] = args;
5822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5823 if (!SWIG_IsOK(res1)) {
5824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5825 }
5826 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 {
5834 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5835 }
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5845 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5846 void *argp1 = 0 ;
5847 int res1 = 0 ;
5848 void *argp2 = 0 ;
5849 int res2 = 0 ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 char * kwnames[] = {
5853 (char *) "self",(char *) "mergefrom", NULL
5854 };
5855
5856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5860 }
5861 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5863 if (!SWIG_IsOK(res2)) {
5864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5865 }
5866 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5867 {
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 (arg1)->MergeWith(arg2);
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 resultobj = SWIG_Py_Void();
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5881 PyObject *resultobj = 0;
5882 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 PyObject *swig_obj[1] ;
5886
5887 if (!args) SWIG_fail;
5888 swig_obj[0] = args;
5889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5892 }
5893 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 (arg1)->IncRef();
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = SWIG_Py_Void();
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 PyObject *resultobj = 0;
5909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 PyObject *swig_obj[1] ;
5913
5914 if (!args) SWIG_fail;
5915 swig_obj[0] = args;
5916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5919 }
5920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 (arg1)->DecRef();
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 resultobj = SWIG_Py_Void();
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj = 0;
5936 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5937 wxColour *arg2 = 0 ;
5938 void *argp1 = 0 ;
5939 int res1 = 0 ;
5940 wxColour temp2 ;
5941 PyObject * obj0 = 0 ;
5942 PyObject * obj1 = 0 ;
5943 char * kwnames[] = {
5944 (char *) "self",(char *) "colText", NULL
5945 };
5946
5947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5949 if (!SWIG_IsOK(res1)) {
5950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5951 }
5952 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5953 {
5954 arg2 = &temp2;
5955 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5956 }
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 (arg1)->SetTextColour((wxColour const &)*arg2);
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 resultobj = SWIG_Py_Void();
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5971 PyObject *resultobj = 0;
5972 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5973 wxColour *arg2 = 0 ;
5974 void *argp1 = 0 ;
5975 int res1 = 0 ;
5976 wxColour temp2 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "self",(char *) "colBack", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5985 if (!SWIG_IsOK(res1)) {
5986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5987 }
5988 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 resultobj = SWIG_Py_Void();
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj = 0;
6008 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6009 wxFont *arg2 = 0 ;
6010 void *argp1 = 0 ;
6011 int res1 = 0 ;
6012 void *argp2 = 0 ;
6013 int res2 = 0 ;
6014 PyObject * obj0 = 0 ;
6015 PyObject * obj1 = 0 ;
6016 char * kwnames[] = {
6017 (char *) "self",(char *) "font", NULL
6018 };
6019
6020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6022 if (!SWIG_IsOK(res1)) {
6023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6024 }
6025 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6026 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6027 if (!SWIG_IsOK(res2)) {
6028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6029 }
6030 if (!argp2) {
6031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6032 }
6033 arg2 = reinterpret_cast< wxFont * >(argp2);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 (arg1)->SetFont((wxFont const &)*arg2);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj = 0;
6049 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6050 int arg2 ;
6051 int arg3 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 int val2 ;
6055 int ecode2 = 0 ;
6056 int val3 ;
6057 int ecode3 = 0 ;
6058 PyObject * obj0 = 0 ;
6059 PyObject * obj1 = 0 ;
6060 PyObject * obj2 = 0 ;
6061 char * kwnames[] = {
6062 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6063 };
6064
6065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6067 if (!SWIG_IsOK(res1)) {
6068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6069 }
6070 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6071 ecode2 = SWIG_AsVal_int(obj1, &val2);
6072 if (!SWIG_IsOK(ecode2)) {
6073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6074 }
6075 arg2 = static_cast< int >(val2);
6076 ecode3 = SWIG_AsVal_int(obj2, &val3);
6077 if (!SWIG_IsOK(ecode3)) {
6078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6079 }
6080 arg3 = static_cast< int >(val3);
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 (arg1)->SetAlignment(arg2,arg3);
6084 wxPyEndAllowThreads(__tstate);
6085 if (PyErr_Occurred()) SWIG_fail;
6086 }
6087 resultobj = SWIG_Py_Void();
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj = 0;
6096 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6097 int arg2 ;
6098 int arg3 ;
6099 void *argp1 = 0 ;
6100 int res1 = 0 ;
6101 int val2 ;
6102 int ecode2 = 0 ;
6103 int val3 ;
6104 int ecode3 = 0 ;
6105 PyObject * obj0 = 0 ;
6106 PyObject * obj1 = 0 ;
6107 PyObject * obj2 = 0 ;
6108 char * kwnames[] = {
6109 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6110 };
6111
6112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6114 if (!SWIG_IsOK(res1)) {
6115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6116 }
6117 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 ecode3 = SWIG_AsVal_int(obj2, &val3);
6124 if (!SWIG_IsOK(ecode3)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6126 }
6127 arg3 = static_cast< int >(val3);
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 (arg1)->SetSize(arg2,arg3);
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_Py_Void();
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj = 0;
6143 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6144 bool arg2 = (bool) true ;
6145 void *argp1 = 0 ;
6146 int res1 = 0 ;
6147 bool val2 ;
6148 int ecode2 = 0 ;
6149 PyObject * obj0 = 0 ;
6150 PyObject * obj1 = 0 ;
6151 char * kwnames[] = {
6152 (char *) "self",(char *) "allow", NULL
6153 };
6154
6155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6157 if (!SWIG_IsOK(res1)) {
6158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6159 }
6160 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6161 if (obj1) {
6162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6163 if (!SWIG_IsOK(ecode2)) {
6164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6165 }
6166 arg2 = static_cast< bool >(val2);
6167 }
6168 {
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 (arg1)->SetOverflow(arg2);
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 resultobj = SWIG_Py_Void();
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6184 bool arg2 = (bool) true ;
6185 void *argp1 = 0 ;
6186 int res1 = 0 ;
6187 bool val2 ;
6188 int ecode2 = 0 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char * kwnames[] = {
6192 (char *) "self",(char *) "isReadOnly", NULL
6193 };
6194
6195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6197 if (!SWIG_IsOK(res1)) {
6198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6199 }
6200 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6201 if (obj1) {
6202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6203 if (!SWIG_IsOK(ecode2)) {
6204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6205 }
6206 arg2 = static_cast< bool >(val2);
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 (arg1)->SetReadOnly(arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_Py_Void();
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6224 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6225 void *argp1 = 0 ;
6226 int res1 = 0 ;
6227 void *argp2 = 0 ;
6228 int res2 = 0 ;
6229 PyObject * obj0 = 0 ;
6230 PyObject * obj1 = 0 ;
6231 char * kwnames[] = {
6232 (char *) "self",(char *) "renderer", NULL
6233 };
6234
6235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6237 if (!SWIG_IsOK(res1)) {
6238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6239 }
6240 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6242 if (!SWIG_IsOK(res2)) {
6243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6244 }
6245 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6246 {
6247 PyThreadState* __tstate = wxPyBeginAllowThreads();
6248 (arg1)->SetRenderer(arg2);
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 resultobj = SWIG_Py_Void();
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj = 0;
6261 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6262 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6263 void *argp1 = 0 ;
6264 int res1 = 0 ;
6265 void *argp2 = 0 ;
6266 int res2 = 0 ;
6267 PyObject * obj0 = 0 ;
6268 PyObject * obj1 = 0 ;
6269 char * kwnames[] = {
6270 (char *) "self",(char *) "editor", NULL
6271 };
6272
6273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6275 if (!SWIG_IsOK(res1)) {
6276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6277 }
6278 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6280 if (!SWIG_IsOK(res2)) {
6281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6282 }
6283 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6284 {
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 (arg1)->SetEditor(arg2);
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 resultobj = SWIG_Py_Void();
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj = 0;
6299 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6300 wxGridCellAttr::wxAttrKind arg2 ;
6301 void *argp1 = 0 ;
6302 int res1 = 0 ;
6303 int val2 ;
6304 int ecode2 = 0 ;
6305 PyObject * obj0 = 0 ;
6306 PyObject * obj1 = 0 ;
6307 char * kwnames[] = {
6308 (char *) "self",(char *) "kind", NULL
6309 };
6310
6311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6313 if (!SWIG_IsOK(res1)) {
6314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6315 }
6316 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6317 ecode2 = SWIG_AsVal_int(obj1, &val2);
6318 if (!SWIG_IsOK(ecode2)) {
6319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6320 }
6321 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 (arg1)->SetKind(arg2);
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_Py_Void();
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6336 PyObject *resultobj = 0;
6337 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6338 bool result;
6339 void *argp1 = 0 ;
6340 int res1 = 0 ;
6341 PyObject *swig_obj[1] ;
6342
6343 if (!args) SWIG_fail;
6344 swig_obj[0] = args;
6345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6346 if (!SWIG_IsOK(res1)) {
6347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6348 }
6349 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6350 {
6351 PyThreadState* __tstate = wxPyBeginAllowThreads();
6352 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 {
6357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6358 }
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6366 PyObject *resultobj = 0;
6367 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6368 bool result;
6369 void *argp1 = 0 ;
6370 int res1 = 0 ;
6371 PyObject *swig_obj[1] ;
6372
6373 if (!args) SWIG_fail;
6374 swig_obj[0] = args;
6375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6378 }
6379 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6380 {
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 {
6387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6388 }
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6398 bool result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 {
6417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6418 }
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6426 PyObject *resultobj = 0;
6427 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6428 bool result;
6429 void *argp1 = 0 ;
6430 int res1 = 0 ;
6431 PyObject *swig_obj[1] ;
6432
6433 if (!args) SWIG_fail;
6434 swig_obj[0] = args;
6435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6436 if (!SWIG_IsOK(res1)) {
6437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6438 }
6439 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6440 {
6441 PyThreadState* __tstate = wxPyBeginAllowThreads();
6442 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 {
6447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6448 }
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456 PyObject *resultobj = 0;
6457 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6458 bool result;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 PyObject *swig_obj[1] ;
6462
6463 if (!args) SWIG_fail;
6464 swig_obj[0] = args;
6465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6468 }
6469 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 {
6477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6478 }
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6486 PyObject *resultobj = 0;
6487 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6488 bool result;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 PyObject *swig_obj[1] ;
6492
6493 if (!args) SWIG_fail;
6494 swig_obj[0] = args;
6495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6496 if (!SWIG_IsOK(res1)) {
6497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6498 }
6499 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 {
6507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6508 }
6509 return resultobj;
6510 fail:
6511 return NULL;
6512 }
6513
6514
6515 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6516 PyObject *resultobj = 0;
6517 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6518 bool result;
6519 void *argp1 = 0 ;
6520 int res1 = 0 ;
6521 PyObject *swig_obj[1] ;
6522
6523 if (!args) SWIG_fail;
6524 swig_obj[0] = args;
6525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6526 if (!SWIG_IsOK(res1)) {
6527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6528 }
6529 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6546 PyObject *resultobj = 0;
6547 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6548 bool result;
6549 void *argp1 = 0 ;
6550 int res1 = 0 ;
6551 PyObject *swig_obj[1] ;
6552
6553 if (!args) SWIG_fail;
6554 swig_obj[0] = args;
6555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6556 if (!SWIG_IsOK(res1)) {
6557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6558 }
6559 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6563 wxPyEndAllowThreads(__tstate);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 {
6567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6568 }
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576 PyObject *resultobj = 0;
6577 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6578 wxColour result;
6579 void *argp1 = 0 ;
6580 int res1 = 0 ;
6581 PyObject *swig_obj[1] ;
6582
6583 if (!args) SWIG_fail;
6584 swig_obj[0] = args;
6585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6588 }
6589 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6604 PyObject *resultobj = 0;
6605 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6606 wxColour result;
6607 void *argp1 = 0 ;
6608 int res1 = 0 ;
6609 PyObject *swig_obj[1] ;
6610
6611 if (!args) SWIG_fail;
6612 swig_obj[0] = args;
6613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6616 }
6617 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632 PyObject *resultobj = 0;
6633 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6634 wxFont result;
6635 void *argp1 = 0 ;
6636 int res1 = 0 ;
6637 PyObject *swig_obj[1] ;
6638
6639 if (!args) SWIG_fail;
6640 swig_obj[0] = args;
6641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6642 if (!SWIG_IsOK(res1)) {
6643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6644 }
6645 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = ((wxGridCellAttr const *)arg1)->GetFont();
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6662 int *arg2 = (int *) 0 ;
6663 int *arg3 = (int *) 0 ;
6664 void *argp1 = 0 ;
6665 int res1 = 0 ;
6666 int temp2 ;
6667 int res2 = SWIG_TMPOBJ ;
6668 int temp3 ;
6669 int res3 = SWIG_TMPOBJ ;
6670 PyObject *swig_obj[1] ;
6671
6672 arg2 = &temp2;
6673 arg3 = &temp3;
6674 if (!args) SWIG_fail;
6675 swig_obj[0] = args;
6676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6679 }
6680 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6681 {
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 resultobj = SWIG_Py_Void();
6688 if (SWIG_IsTmpObj(res2)) {
6689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6690 } else {
6691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6693 }
6694 if (SWIG_IsTmpObj(res3)) {
6695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6696 } else {
6697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6699 }
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6707 PyObject *resultobj = 0;
6708 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6709 int *arg2 = (int *) 0 ;
6710 int *arg3 = (int *) 0 ;
6711 void *argp1 = 0 ;
6712 int res1 = 0 ;
6713 int temp2 ;
6714 int res2 = SWIG_TMPOBJ ;
6715 int temp3 ;
6716 int res3 = SWIG_TMPOBJ ;
6717 PyObject *swig_obj[1] ;
6718
6719 arg2 = &temp2;
6720 arg3 = &temp3;
6721 if (!args) SWIG_fail;
6722 swig_obj[0] = args;
6723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6726 }
6727 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 if (SWIG_IsTmpObj(res2)) {
6736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6737 } else {
6738 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6740 }
6741 if (SWIG_IsTmpObj(res3)) {
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6743 } else {
6744 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6746 }
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6754 PyObject *resultobj = 0;
6755 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6756 bool result;
6757 void *argp1 = 0 ;
6758 int res1 = 0 ;
6759 PyObject *swig_obj[1] ;
6760
6761 if (!args) SWIG_fail;
6762 swig_obj[0] = args;
6763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6764 if (!SWIG_IsOK(res1)) {
6765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6766 }
6767 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6768 {
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6784 PyObject *resultobj = 0;
6785 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6786 wxGrid *arg2 = (wxGrid *) 0 ;
6787 int arg3 ;
6788 int arg4 ;
6789 wxGridCellRenderer *result = 0 ;
6790 void *argp1 = 0 ;
6791 int res1 = 0 ;
6792 void *argp2 = 0 ;
6793 int res2 = 0 ;
6794 int val3 ;
6795 int ecode3 = 0 ;
6796 int val4 ;
6797 int ecode4 = 0 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 PyObject * obj2 = 0 ;
6801 PyObject * obj3 = 0 ;
6802 char * kwnames[] = {
6803 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6804 };
6805
6806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6810 }
6811 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6813 if (!SWIG_IsOK(res2)) {
6814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6815 }
6816 arg2 = reinterpret_cast< wxGrid * >(argp2);
6817 ecode3 = SWIG_AsVal_int(obj2, &val3);
6818 if (!SWIG_IsOK(ecode3)) {
6819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6820 }
6821 arg3 = static_cast< int >(val3);
6822 ecode4 = SWIG_AsVal_int(obj3, &val4);
6823 if (!SWIG_IsOK(ecode4)) {
6824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6825 }
6826 arg4 = static_cast< int >(val4);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 {
6834 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6843 PyObject *resultobj = 0;
6844 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6845 wxGrid *arg2 = (wxGrid *) 0 ;
6846 int arg3 ;
6847 int arg4 ;
6848 wxGridCellEditor *result = 0 ;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 void *argp2 = 0 ;
6852 int res2 = 0 ;
6853 int val3 ;
6854 int ecode3 = 0 ;
6855 int val4 ;
6856 int ecode4 = 0 ;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 PyObject * obj2 = 0 ;
6860 PyObject * obj3 = 0 ;
6861 char * kwnames[] = {
6862 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6863 };
6864
6865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6872 if (!SWIG_IsOK(res2)) {
6873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6874 }
6875 arg2 = reinterpret_cast< wxGrid * >(argp2);
6876 ecode3 = SWIG_AsVal_int(obj2, &val3);
6877 if (!SWIG_IsOK(ecode3)) {
6878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6879 }
6880 arg3 = static_cast< int >(val3);
6881 ecode4 = SWIG_AsVal_int(obj3, &val4);
6882 if (!SWIG_IsOK(ecode4)) {
6883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6884 }
6885 arg4 = static_cast< int >(val4);
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 {
6893 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6894 }
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902 PyObject *resultobj = 0;
6903 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6904 bool result;
6905 void *argp1 = 0 ;
6906 int res1 = 0 ;
6907 PyObject *swig_obj[1] ;
6908
6909 if (!args) SWIG_fail;
6910 swig_obj[0] = args;
6911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6912 if (!SWIG_IsOK(res1)) {
6913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6914 }
6915 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6916 {
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 {
6923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6924 }
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6934 wxGridCellAttr::wxAttrKind result;
6935 void *argp1 = 0 ;
6936 int res1 = 0 ;
6937 PyObject *swig_obj[1] ;
6938
6939 if (!args) SWIG_fail;
6940 swig_obj[0] = args;
6941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6944 }
6945 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_From_int(static_cast< int >(result));
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = 0;
6961 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6962 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 void *argp2 = 0 ;
6966 int res2 = 0 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "self",(char *) "defAttr", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6977 }
6978 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6980 if (!SWIG_IsOK(res2)) {
6981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6982 }
6983 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->SetDefAttr(arg2);
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_Py_Void();
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6998 PyObject *obj;
6999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7000 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7001 return SWIG_Py_Void();
7002 }
7003
7004 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 return SWIG_Python_InitShadowInstance(args);
7006 }
7007
7008 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxGridCellAttrProvider *result = 0 ;
7011
7012 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7013 {
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 {
7020 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7021 }
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj = 0;
7030 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7031 PyObject *arg2 = (PyObject *) 0 ;
7032 void *argp1 = 0 ;
7033 int res1 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "_self", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7044 }
7045 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7046 arg2 = obj1;
7047 {
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_Py_Void();
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7063 int arg2 ;
7064 int arg3 ;
7065 wxGridCellAttr::wxAttrKind arg4 ;
7066 wxGridCellAttr *result = 0 ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 int val2 ;
7070 int ecode2 = 0 ;
7071 int val3 ;
7072 int ecode3 = 0 ;
7073 int val4 ;
7074 int ecode4 = 0 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 PyObject * obj2 = 0 ;
7078 PyObject * obj3 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7087 }
7088 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7089 ecode2 = SWIG_AsVal_int(obj1, &val2);
7090 if (!SWIG_IsOK(ecode2)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7092 }
7093 arg2 = static_cast< int >(val2);
7094 ecode3 = SWIG_AsVal_int(obj2, &val3);
7095 if (!SWIG_IsOK(ecode3)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7097 }
7098 arg3 = static_cast< int >(val3);
7099 ecode4 = SWIG_AsVal_int(obj3, &val4);
7100 if (!SWIG_IsOK(ecode4)) {
7101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7102 }
7103 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 {
7111 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7112 }
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj = 0;
7121 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7122 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7123 int arg3 ;
7124 int arg4 ;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 void *argp2 = 0 ;
7128 int res2 = 0 ;
7129 int val3 ;
7130 int ecode3 = 0 ;
7131 int val4 ;
7132 int ecode4 = 0 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 PyObject * obj2 = 0 ;
7136 PyObject * obj3 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7145 }
7146 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7148 if (!SWIG_IsOK(res2)) {
7149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7150 }
7151 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 ecode4 = SWIG_AsVal_int(obj3, &val4);
7158 if (!SWIG_IsOK(ecode4)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7160 }
7161 arg4 = static_cast< int >(val4);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 (arg1)->SetAttr(arg2,arg3,arg4);
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_Py_Void();
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj = 0;
7177 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7178 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7179 int arg3 ;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 void *argp2 = 0 ;
7183 int res2 = 0 ;
7184 int val3 ;
7185 int ecode3 = 0 ;
7186 PyObject * obj0 = 0 ;
7187 PyObject * obj1 = 0 ;
7188 PyObject * obj2 = 0 ;
7189 char * kwnames[] = {
7190 (char *) "self",(char *) "attr",(char *) "row", NULL
7191 };
7192
7193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7195 if (!SWIG_IsOK(res1)) {
7196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7197 }
7198 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7200 if (!SWIG_IsOK(res2)) {
7201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7202 }
7203 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7204 ecode3 = SWIG_AsVal_int(obj2, &val3);
7205 if (!SWIG_IsOK(ecode3)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7207 }
7208 arg3 = static_cast< int >(val3);
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->SetRowAttr(arg2,arg3);
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7225 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7226 int arg3 ;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 void *argp2 = 0 ;
7230 int res2 = 0 ;
7231 int val3 ;
7232 int ecode3 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 PyObject * obj2 = 0 ;
7236 char * kwnames[] = {
7237 (char *) "self",(char *) "attr",(char *) "col", NULL
7238 };
7239
7240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7242 if (!SWIG_IsOK(res1)) {
7243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7244 }
7245 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7247 if (!SWIG_IsOK(res2)) {
7248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7249 }
7250 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7251 ecode3 = SWIG_AsVal_int(obj2, &val3);
7252 if (!SWIG_IsOK(ecode3)) {
7253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7254 }
7255 arg3 = static_cast< int >(val3);
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 (arg1)->SetColAttr(arg2,arg3);
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 resultobj = SWIG_Py_Void();
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj = 0;
7271 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7272 size_t arg2 ;
7273 int arg3 ;
7274 void *argp1 = 0 ;
7275 int res1 = 0 ;
7276 size_t val2 ;
7277 int ecode2 = 0 ;
7278 int val3 ;
7279 int ecode3 = 0 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 PyObject * obj2 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7291 }
7292 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7294 if (!SWIG_IsOK(ecode2)) {
7295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7296 }
7297 arg2 = static_cast< size_t >(val2);
7298 ecode3 = SWIG_AsVal_int(obj2, &val3);
7299 if (!SWIG_IsOK(ecode3)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7301 }
7302 arg3 = static_cast< int >(val3);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->UpdateAttrRows(arg2,arg3);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_Py_Void();
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7319 size_t arg2 ;
7320 int arg3 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 size_t val2 ;
7324 int ecode2 = 0 ;
7325 int val3 ;
7326 int ecode3 = 0 ;
7327 PyObject * obj0 = 0 ;
7328 PyObject * obj1 = 0 ;
7329 PyObject * obj2 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7338 }
7339 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7340 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7341 if (!SWIG_IsOK(ecode2)) {
7342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7343 }
7344 arg2 = static_cast< size_t >(val2);
7345 ecode3 = SWIG_AsVal_int(obj2, &val3);
7346 if (!SWIG_IsOK(ecode3)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7348 }
7349 arg3 = static_cast< int >(val3);
7350 {
7351 PyThreadState* __tstate = wxPyBeginAllowThreads();
7352 (arg1)->UpdateAttrCols(arg2,arg3);
7353 wxPyEndAllowThreads(__tstate);
7354 if (PyErr_Occurred()) SWIG_fail;
7355 }
7356 resultobj = SWIG_Py_Void();
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7364 PyObject *obj;
7365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7367 return SWIG_Py_Void();
7368 }
7369
7370 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 return SWIG_Python_InitShadowInstance(args);
7372 }
7373
7374 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxPyGridCellAttrProvider *result = 0 ;
7377
7378 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7379 {
7380 PyThreadState* __tstate = wxPyBeginAllowThreads();
7381 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7395 PyObject *arg2 = (PyObject *) 0 ;
7396 PyObject *arg3 = (PyObject *) 0 ;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 PyObject * obj0 = 0 ;
7400 PyObject * obj1 = 0 ;
7401 PyObject * obj2 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "self",(char *) "_class", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7410 }
7411 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7412 arg2 = obj1;
7413 arg3 = obj2;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->_setCallbackInfo(arg2,arg3);
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_Py_Void();
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7430 int arg2 ;
7431 int arg3 ;
7432 wxGridCellAttr::wxAttrKind arg4 ;
7433 wxGridCellAttr *result = 0 ;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 int val2 ;
7437 int ecode2 = 0 ;
7438 int val3 ;
7439 int ecode3 = 0 ;
7440 int val4 ;
7441 int ecode4 = 0 ;
7442 PyObject * obj0 = 0 ;
7443 PyObject * obj1 = 0 ;
7444 PyObject * obj2 = 0 ;
7445 PyObject * obj3 = 0 ;
7446 char * kwnames[] = {
7447 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7448 };
7449
7450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7452 if (!SWIG_IsOK(res1)) {
7453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7454 }
7455 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7456 ecode2 = SWIG_AsVal_int(obj1, &val2);
7457 if (!SWIG_IsOK(ecode2)) {
7458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7459 }
7460 arg2 = static_cast< int >(val2);
7461 ecode3 = SWIG_AsVal_int(obj2, &val3);
7462 if (!SWIG_IsOK(ecode3)) {
7463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7464 }
7465 arg3 = static_cast< int >(val3);
7466 ecode4 = SWIG_AsVal_int(obj3, &val4);
7467 if (!SWIG_IsOK(ecode4)) {
7468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7469 }
7470 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj = 0;
7488 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7489 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7490 int arg3 ;
7491 int arg4 ;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 void *argp2 = 0 ;
7495 int res2 = 0 ;
7496 int val3 ;
7497 int ecode3 = 0 ;
7498 int val4 ;
7499 int ecode4 = 0 ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 PyObject * obj2 = 0 ;
7503 PyObject * obj3 = 0 ;
7504 char * kwnames[] = {
7505 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7506 };
7507
7508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7510 if (!SWIG_IsOK(res1)) {
7511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7512 }
7513 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7515 if (!SWIG_IsOK(res2)) {
7516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7517 }
7518 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7519 ecode3 = SWIG_AsVal_int(obj2, &val3);
7520 if (!SWIG_IsOK(ecode3)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7522 }
7523 arg3 = static_cast< int >(val3);
7524 ecode4 = SWIG_AsVal_int(obj3, &val4);
7525 if (!SWIG_IsOK(ecode4)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7527 }
7528 arg4 = static_cast< int >(val4);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->SetAttr(arg2,arg3,arg4);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 resultobj = SWIG_Py_Void();
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj = 0;
7544 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7545 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7546 int arg3 ;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 void *argp2 = 0 ;
7550 int res2 = 0 ;
7551 int val3 ;
7552 int ecode3 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 PyObject * obj2 = 0 ;
7556 char * kwnames[] = {
7557 (char *) "self",(char *) "attr",(char *) "row", NULL
7558 };
7559
7560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7562 if (!SWIG_IsOK(res1)) {
7563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7564 }
7565 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7567 if (!SWIG_IsOK(res2)) {
7568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7569 }
7570 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7571 ecode3 = SWIG_AsVal_int(obj2, &val3);
7572 if (!SWIG_IsOK(ecode3)) {
7573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7574 }
7575 arg3 = static_cast< int >(val3);
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 (arg1)->SetRowAttr(arg2,arg3);
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_Py_Void();
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7592 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7593 int arg3 ;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 void *argp2 = 0 ;
7597 int res2 = 0 ;
7598 int val3 ;
7599 int ecode3 = 0 ;
7600 PyObject * obj0 = 0 ;
7601 PyObject * obj1 = 0 ;
7602 PyObject * obj2 = 0 ;
7603 char * kwnames[] = {
7604 (char *) "self",(char *) "attr",(char *) "col", NULL
7605 };
7606
7607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7609 if (!SWIG_IsOK(res1)) {
7610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7611 }
7612 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7614 if (!SWIG_IsOK(res2)) {
7615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7616 }
7617 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7618 ecode3 = SWIG_AsVal_int(obj2, &val3);
7619 if (!SWIG_IsOK(ecode3)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7621 }
7622 arg3 = static_cast< int >(val3);
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 (arg1)->SetColAttr(arg2,arg3);
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_Py_Void();
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *obj;
7638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7640 return SWIG_Py_Void();
7641 }
7642
7643 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7644 return SWIG_Python_InitShadowInstance(args);
7645 }
7646
7647 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 PyObject *swig_obj[1] ;
7653
7654 if (!args) SWIG_fail;
7655 swig_obj[0] = args;
7656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7659 }
7660 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 delete arg1;
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 resultobj = SWIG_Py_Void();
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj = 0;
7677 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7678 PyObject *arg2 = (PyObject *) 0 ;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 PyObject * obj0 = 0 ;
7682 PyObject * obj1 = 0 ;
7683 char * kwnames[] = {
7684 (char *) "self",(char *) "_self", NULL
7685 };
7686
7687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7689 if (!SWIG_IsOK(res1)) {
7690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7691 }
7692 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7693 arg2 = obj1;
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 wxGridTableBase__setOORInfo(arg1,arg2);
7697 wxPyEndAllowThreads(__tstate);
7698 if (PyErr_Occurred()) SWIG_fail;
7699 }
7700 resultobj = SWIG_Py_Void();
7701 return resultobj;
7702 fail:
7703 return NULL;
7704 }
7705
7706
7707 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7708 PyObject *resultobj = 0;
7709 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7710 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 void *argp2 = 0 ;
7714 int res2 = 0 ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "attrProvider", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7725 }
7726 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7728 if (!SWIG_IsOK(res2)) {
7729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7730 }
7731 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7732 {
7733 PyThreadState* __tstate = wxPyBeginAllowThreads();
7734 (arg1)->SetAttrProvider(arg2);
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 resultobj = SWIG_Py_Void();
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7746 PyObject *resultobj = 0;
7747 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7748 wxGridCellAttrProvider *result = 0 ;
7749 void *argp1 = 0 ;
7750 int res1 = 0 ;
7751 PyObject *swig_obj[1] ;
7752
7753 if (!args) SWIG_fail;
7754 swig_obj[0] = args;
7755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7756 if (!SWIG_IsOK(res1)) {
7757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7758 }
7759 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7768 }
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj = 0;
7777 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7778 wxGrid *arg2 = (wxGrid *) 0 ;
7779 void *argp1 = 0 ;
7780 int res1 = 0 ;
7781 void *argp2 = 0 ;
7782 int res2 = 0 ;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 char * kwnames[] = {
7786 (char *) "self",(char *) "grid", NULL
7787 };
7788
7789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7793 }
7794 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7796 if (!SWIG_IsOK(res2)) {
7797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7798 }
7799 arg2 = reinterpret_cast< wxGrid * >(argp2);
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 (arg1)->SetView(arg2);
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 resultobj = SWIG_Py_Void();
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7814 PyObject *resultobj = 0;
7815 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7816 wxGrid *result = 0 ;
7817 void *argp1 = 0 ;
7818 int res1 = 0 ;
7819 PyObject *swig_obj[1] ;
7820
7821 if (!args) SWIG_fail;
7822 swig_obj[0] = args;
7823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7824 if (!SWIG_IsOK(res1)) {
7825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7826 }
7827 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7831 wxPyEndAllowThreads(__tstate);
7832 if (PyErr_Occurred()) SWIG_fail;
7833 }
7834 {
7835 resultobj = wxPyMake_wxObject(result, (bool)0);
7836 }
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7844 PyObject *resultobj = 0;
7845 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7846 int result;
7847 void *argp1 = 0 ;
7848 int res1 = 0 ;
7849 PyObject *swig_obj[1] ;
7850
7851 if (!args) SWIG_fail;
7852 swig_obj[0] = args;
7853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7854 if (!SWIG_IsOK(res1)) {
7855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7856 }
7857 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7858 {
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 result = (int)(arg1)->GetNumberRows();
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_From_int(static_cast< int >(result));
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7872 PyObject *resultobj = 0;
7873 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7874 int result;
7875 void *argp1 = 0 ;
7876 int res1 = 0 ;
7877 PyObject *swig_obj[1] ;
7878
7879 if (!args) SWIG_fail;
7880 swig_obj[0] = args;
7881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7882 if (!SWIG_IsOK(res1)) {
7883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7884 }
7885 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 result = (int)(arg1)->GetNumberCols();
7889 wxPyEndAllowThreads(__tstate);
7890 if (PyErr_Occurred()) SWIG_fail;
7891 }
7892 resultobj = SWIG_From_int(static_cast< int >(result));
7893 return resultobj;
7894 fail:
7895 return NULL;
7896 }
7897
7898
7899 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7900 PyObject *resultobj = 0;
7901 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7902 int arg2 ;
7903 int arg3 ;
7904 bool result;
7905 void *argp1 = 0 ;
7906 int res1 = 0 ;
7907 int val2 ;
7908 int ecode2 = 0 ;
7909 int val3 ;
7910 int ecode3 = 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 PyObject * obj2 = 0 ;
7914 char * kwnames[] = {
7915 (char *) "self",(char *) "row",(char *) "col", NULL
7916 };
7917
7918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7920 if (!SWIG_IsOK(res1)) {
7921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7922 }
7923 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7924 ecode2 = SWIG_AsVal_int(obj1, &val2);
7925 if (!SWIG_IsOK(ecode2)) {
7926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7927 }
7928 arg2 = static_cast< int >(val2);
7929 ecode3 = SWIG_AsVal_int(obj2, &val3);
7930 if (!SWIG_IsOK(ecode3)) {
7931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7932 }
7933 arg3 = static_cast< int >(val3);
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj = 0;
7951 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7952 int arg2 ;
7953 int arg3 ;
7954 wxString result;
7955 void *argp1 = 0 ;
7956 int res1 = 0 ;
7957 int val2 ;
7958 int ecode2 = 0 ;
7959 int val3 ;
7960 int ecode3 = 0 ;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 PyObject * obj2 = 0 ;
7964 char * kwnames[] = {
7965 (char *) "self",(char *) "row",(char *) "col", NULL
7966 };
7967
7968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7970 if (!SWIG_IsOK(res1)) {
7971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7972 }
7973 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7974 ecode2 = SWIG_AsVal_int(obj1, &val2);
7975 if (!SWIG_IsOK(ecode2)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7977 }
7978 arg2 = static_cast< int >(val2);
7979 ecode3 = SWIG_AsVal_int(obj2, &val3);
7980 if (!SWIG_IsOK(ecode3)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7982 }
7983 arg3 = static_cast< int >(val3);
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (arg1)->GetValue(arg2,arg3);
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 {
7991 #if wxUSE_UNICODE
7992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7993 #else
7994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7995 #endif
7996 }
7997 return resultobj;
7998 fail:
7999 return NULL;
8000 }
8001
8002
8003 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8004 PyObject *resultobj = 0;
8005 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8006 int arg2 ;
8007 int arg3 ;
8008 wxString *arg4 = 0 ;
8009 void *argp1 = 0 ;
8010 int res1 = 0 ;
8011 int val2 ;
8012 int ecode2 = 0 ;
8013 int val3 ;
8014 int ecode3 = 0 ;
8015 bool temp4 = false ;
8016 PyObject * obj0 = 0 ;
8017 PyObject * obj1 = 0 ;
8018 PyObject * obj2 = 0 ;
8019 PyObject * obj3 = 0 ;
8020 char * kwnames[] = {
8021 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8022 };
8023
8024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8026 if (!SWIG_IsOK(res1)) {
8027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8028 }
8029 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8030 ecode2 = SWIG_AsVal_int(obj1, &val2);
8031 if (!SWIG_IsOK(ecode2)) {
8032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8033 }
8034 arg2 = static_cast< int >(val2);
8035 ecode3 = SWIG_AsVal_int(obj2, &val3);
8036 if (!SWIG_IsOK(ecode3)) {
8037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8038 }
8039 arg3 = static_cast< int >(val3);
8040 {
8041 arg4 = wxString_in_helper(obj3);
8042 if (arg4 == NULL) SWIG_fail;
8043 temp4 = true;
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 {
8053 if (temp4)
8054 delete arg4;
8055 }
8056 return resultobj;
8057 fail:
8058 {
8059 if (temp4)
8060 delete arg4;
8061 }
8062 return NULL;
8063 }
8064
8065
8066 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8067 PyObject *resultobj = 0;
8068 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8069 int arg2 ;
8070 int arg3 ;
8071 wxString result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 int val2 ;
8075 int ecode2 = 0 ;
8076 int val3 ;
8077 int ecode3 = 0 ;
8078 PyObject * obj0 = 0 ;
8079 PyObject * obj1 = 0 ;
8080 PyObject * obj2 = 0 ;
8081 char * kwnames[] = {
8082 (char *) "self",(char *) "row",(char *) "col", NULL
8083 };
8084
8085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8089 }
8090 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8091 ecode2 = SWIG_AsVal_int(obj1, &val2);
8092 if (!SWIG_IsOK(ecode2)) {
8093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8094 }
8095 arg2 = static_cast< int >(val2);
8096 ecode3 = SWIG_AsVal_int(obj2, &val3);
8097 if (!SWIG_IsOK(ecode3)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8099 }
8100 arg3 = static_cast< int >(val3);
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (arg1)->GetTypeName(arg2,arg3);
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 #if wxUSE_UNICODE
8109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8110 #else
8111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8112 #endif
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj = 0;
8122 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8123 int arg2 ;
8124 int arg3 ;
8125 wxString *arg4 = 0 ;
8126 bool result;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 int val2 ;
8130 int ecode2 = 0 ;
8131 int val3 ;
8132 int ecode3 = 0 ;
8133 bool temp4 = false ;
8134 PyObject * obj0 = 0 ;
8135 PyObject * obj1 = 0 ;
8136 PyObject * obj2 = 0 ;
8137 PyObject * obj3 = 0 ;
8138 char * kwnames[] = {
8139 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8140 };
8141
8142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8144 if (!SWIG_IsOK(res1)) {
8145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8146 }
8147 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8148 ecode2 = SWIG_AsVal_int(obj1, &val2);
8149 if (!SWIG_IsOK(ecode2)) {
8150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8151 }
8152 arg2 = static_cast< int >(val2);
8153 ecode3 = SWIG_AsVal_int(obj2, &val3);
8154 if (!SWIG_IsOK(ecode3)) {
8155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8156 }
8157 arg3 = static_cast< int >(val3);
8158 {
8159 arg4 = wxString_in_helper(obj3);
8160 if (arg4 == NULL) SWIG_fail;
8161 temp4 = true;
8162 }
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8171 }
8172 {
8173 if (temp4)
8174 delete arg4;
8175 }
8176 return resultobj;
8177 fail:
8178 {
8179 if (temp4)
8180 delete arg4;
8181 }
8182 return NULL;
8183 }
8184
8185
8186 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj = 0;
8188 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8189 int arg2 ;
8190 int arg3 ;
8191 wxString *arg4 = 0 ;
8192 bool result;
8193 void *argp1 = 0 ;
8194 int res1 = 0 ;
8195 int val2 ;
8196 int ecode2 = 0 ;
8197 int val3 ;
8198 int ecode3 = 0 ;
8199 bool temp4 = false ;
8200 PyObject * obj0 = 0 ;
8201 PyObject * obj1 = 0 ;
8202 PyObject * obj2 = 0 ;
8203 PyObject * obj3 = 0 ;
8204 char * kwnames[] = {
8205 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8206 };
8207
8208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8210 if (!SWIG_IsOK(res1)) {
8211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8212 }
8213 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8214 ecode2 = SWIG_AsVal_int(obj1, &val2);
8215 if (!SWIG_IsOK(ecode2)) {
8216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8217 }
8218 arg2 = static_cast< int >(val2);
8219 ecode3 = SWIG_AsVal_int(obj2, &val3);
8220 if (!SWIG_IsOK(ecode3)) {
8221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8222 }
8223 arg3 = static_cast< int >(val3);
8224 {
8225 arg4 = wxString_in_helper(obj3);
8226 if (arg4 == NULL) SWIG_fail;
8227 temp4 = true;
8228 }
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 {
8236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8237 }
8238 {
8239 if (temp4)
8240 delete arg4;
8241 }
8242 return resultobj;
8243 fail:
8244 {
8245 if (temp4)
8246 delete arg4;
8247 }
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = 0;
8254 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8255 int arg2 ;
8256 int arg3 ;
8257 long result;
8258 void *argp1 = 0 ;
8259 int res1 = 0 ;
8260 int val2 ;
8261 int ecode2 = 0 ;
8262 int val3 ;
8263 int ecode3 = 0 ;
8264 PyObject * obj0 = 0 ;
8265 PyObject * obj1 = 0 ;
8266 PyObject * obj2 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "self",(char *) "row",(char *) "col", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8273 if (!SWIG_IsOK(res1)) {
8274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8275 }
8276 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8277 ecode2 = SWIG_AsVal_int(obj1, &val2);
8278 if (!SWIG_IsOK(ecode2)) {
8279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8280 }
8281 arg2 = static_cast< int >(val2);
8282 ecode3 = SWIG_AsVal_int(obj2, &val3);
8283 if (!SWIG_IsOK(ecode3)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8285 }
8286 arg3 = static_cast< int >(val3);
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_From_long(static_cast< long >(result));
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8303 int arg2 ;
8304 int arg3 ;
8305 double result;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 int val2 ;
8309 int ecode2 = 0 ;
8310 int val3 ;
8311 int ecode3 = 0 ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 char * kwnames[] = {
8316 (char *) "self",(char *) "row",(char *) "col", NULL
8317 };
8318
8319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8323 }
8324 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8325 ecode2 = SWIG_AsVal_int(obj1, &val2);
8326 if (!SWIG_IsOK(ecode2)) {
8327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8328 }
8329 arg2 = static_cast< int >(val2);
8330 ecode3 = SWIG_AsVal_int(obj2, &val3);
8331 if (!SWIG_IsOK(ecode3)) {
8332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8333 }
8334 arg3 = static_cast< int >(val3);
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 resultobj = SWIG_From_double(static_cast< double >(result));
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj = 0;
8350 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8351 int arg2 ;
8352 int arg3 ;
8353 bool result;
8354 void *argp1 = 0 ;
8355 int res1 = 0 ;
8356 int val2 ;
8357 int ecode2 = 0 ;
8358 int val3 ;
8359 int ecode3 = 0 ;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 PyObject * obj2 = 0 ;
8363 char * kwnames[] = {
8364 (char *) "self",(char *) "row",(char *) "col", NULL
8365 };
8366
8367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8369 if (!SWIG_IsOK(res1)) {
8370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8371 }
8372 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8373 ecode2 = SWIG_AsVal_int(obj1, &val2);
8374 if (!SWIG_IsOK(ecode2)) {
8375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8376 }
8377 arg2 = static_cast< int >(val2);
8378 ecode3 = SWIG_AsVal_int(obj2, &val3);
8379 if (!SWIG_IsOK(ecode3)) {
8380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8381 }
8382 arg3 = static_cast< int >(val3);
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 {
8390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8401 int arg2 ;
8402 int arg3 ;
8403 long arg4 ;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 int val2 ;
8407 int ecode2 = 0 ;
8408 int val3 ;
8409 int ecode3 = 0 ;
8410 long val4 ;
8411 int ecode4 = 0 ;
8412 PyObject * obj0 = 0 ;
8413 PyObject * obj1 = 0 ;
8414 PyObject * obj2 = 0 ;
8415 PyObject * obj3 = 0 ;
8416 char * kwnames[] = {
8417 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8418 };
8419
8420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8422 if (!SWIG_IsOK(res1)) {
8423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8424 }
8425 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8426 ecode2 = SWIG_AsVal_int(obj1, &val2);
8427 if (!SWIG_IsOK(ecode2)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8429 }
8430 arg2 = static_cast< int >(val2);
8431 ecode3 = SWIG_AsVal_int(obj2, &val3);
8432 if (!SWIG_IsOK(ecode3)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8434 }
8435 arg3 = static_cast< int >(val3);
8436 ecode4 = SWIG_AsVal_long(obj3, &val4);
8437 if (!SWIG_IsOK(ecode4)) {
8438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8439 }
8440 arg4 = static_cast< long >(val4);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_Py_Void();
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj = 0;
8456 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8457 int arg2 ;
8458 int arg3 ;
8459 double arg4 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int val2 ;
8463 int ecode2 = 0 ;
8464 int val3 ;
8465 int ecode3 = 0 ;
8466 double val4 ;
8467 int ecode4 = 0 ;
8468 PyObject * obj0 = 0 ;
8469 PyObject * obj1 = 0 ;
8470 PyObject * obj2 = 0 ;
8471 PyObject * obj3 = 0 ;
8472 char * kwnames[] = {
8473 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8474 };
8475
8476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8478 if (!SWIG_IsOK(res1)) {
8479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8480 }
8481 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8482 ecode2 = SWIG_AsVal_int(obj1, &val2);
8483 if (!SWIG_IsOK(ecode2)) {
8484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8485 }
8486 arg2 = static_cast< int >(val2);
8487 ecode3 = SWIG_AsVal_int(obj2, &val3);
8488 if (!SWIG_IsOK(ecode3)) {
8489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8490 }
8491 arg3 = static_cast< int >(val3);
8492 ecode4 = SWIG_AsVal_double(obj3, &val4);
8493 if (!SWIG_IsOK(ecode4)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8495 }
8496 arg4 = static_cast< double >(val4);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj = 0;
8512 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8513 int arg2 ;
8514 int arg3 ;
8515 bool arg4 ;
8516 void *argp1 = 0 ;
8517 int res1 = 0 ;
8518 int val2 ;
8519 int ecode2 = 0 ;
8520 int val3 ;
8521 int ecode3 = 0 ;
8522 bool val4 ;
8523 int ecode4 = 0 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 PyObject * obj2 = 0 ;
8527 PyObject * obj3 = 0 ;
8528 char * kwnames[] = {
8529 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8530 };
8531
8532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8534 if (!SWIG_IsOK(res1)) {
8535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8536 }
8537 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8538 ecode2 = SWIG_AsVal_int(obj1, &val2);
8539 if (!SWIG_IsOK(ecode2)) {
8540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8541 }
8542 arg2 = static_cast< int >(val2);
8543 ecode3 = SWIG_AsVal_int(obj2, &val3);
8544 if (!SWIG_IsOK(ecode3)) {
8545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8546 }
8547 arg3 = static_cast< int >(val3);
8548 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8549 if (!SWIG_IsOK(ecode4)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8551 }
8552 arg4 = static_cast< bool >(val4);
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 resultobj = SWIG_Py_Void();
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8569 void *argp1 = 0 ;
8570 int res1 = 0 ;
8571 PyObject *swig_obj[1] ;
8572
8573 if (!args) SWIG_fail;
8574 swig_obj[0] = args;
8575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8576 if (!SWIG_IsOK(res1)) {
8577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8578 }
8579 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 (arg1)->Clear();
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 resultobj = SWIG_Py_Void();
8587 return resultobj;
8588 fail:
8589 return NULL;
8590 }
8591
8592
8593 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj = 0;
8595 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8596 size_t arg2 = (size_t) 0 ;
8597 size_t arg3 = (size_t) 1 ;
8598 bool result;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 size_t val2 ;
8602 int ecode2 = 0 ;
8603 size_t val3 ;
8604 int ecode3 = 0 ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 PyObject * obj2 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8616 }
8617 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8618 if (obj1) {
8619 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8620 if (!SWIG_IsOK(ecode2)) {
8621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8622 }
8623 arg2 = static_cast< size_t >(val2);
8624 }
8625 if (obj2) {
8626 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8627 if (!SWIG_IsOK(ecode3)) {
8628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8629 }
8630 arg3 = static_cast< size_t >(val3);
8631 }
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 result = (bool)(arg1)->InsertRows(arg2,arg3);
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 {
8639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8640 }
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj = 0;
8649 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8650 size_t arg2 = (size_t) 1 ;
8651 bool result;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 size_t val2 ;
8655 int ecode2 = 0 ;
8656 PyObject * obj0 = 0 ;
8657 PyObject * obj1 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "numRows", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8666 }
8667 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8668 if (obj1) {
8669 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8670 if (!SWIG_IsOK(ecode2)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8672 }
8673 arg2 = static_cast< size_t >(val2);
8674 }
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (bool)(arg1)->AppendRows(arg2);
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj = 0;
8692 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8693 size_t arg2 = (size_t) 0 ;
8694 size_t arg3 = (size_t) 1 ;
8695 bool result;
8696 void *argp1 = 0 ;
8697 int res1 = 0 ;
8698 size_t val2 ;
8699 int ecode2 = 0 ;
8700 size_t val3 ;
8701 int ecode3 = 0 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 PyObject * obj2 = 0 ;
8705 char * kwnames[] = {
8706 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8707 };
8708
8709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8711 if (!SWIG_IsOK(res1)) {
8712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8713 }
8714 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8715 if (obj1) {
8716 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8717 if (!SWIG_IsOK(ecode2)) {
8718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8719 }
8720 arg2 = static_cast< size_t >(val2);
8721 }
8722 if (obj2) {
8723 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8724 if (!SWIG_IsOK(ecode3)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8726 }
8727 arg3 = static_cast< size_t >(val3);
8728 }
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 {
8736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8737 }
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8747 size_t arg2 = (size_t) 0 ;
8748 size_t arg3 = (size_t) 1 ;
8749 bool result;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 size_t val2 ;
8753 int ecode2 = 0 ;
8754 size_t val3 ;
8755 int ecode3 = 0 ;
8756 PyObject * obj0 = 0 ;
8757 PyObject * obj1 = 0 ;
8758 PyObject * obj2 = 0 ;
8759 char * kwnames[] = {
8760 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8761 };
8762
8763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8765 if (!SWIG_IsOK(res1)) {
8766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8767 }
8768 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8769 if (obj1) {
8770 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8773 }
8774 arg2 = static_cast< size_t >(val2);
8775 }
8776 if (obj2) {
8777 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8778 if (!SWIG_IsOK(ecode3)) {
8779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8780 }
8781 arg3 = static_cast< size_t >(val3);
8782 }
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 result = (bool)(arg1)->InsertCols(arg2,arg3);
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 {
8790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8791 }
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj = 0;
8800 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8801 size_t arg2 = (size_t) 1 ;
8802 bool result;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 size_t val2 ;
8806 int ecode2 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 PyObject * obj1 = 0 ;
8809 char * kwnames[] = {
8810 (char *) "self",(char *) "numCols", NULL
8811 };
8812
8813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8817 }
8818 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8819 if (obj1) {
8820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8823 }
8824 arg2 = static_cast< size_t >(val2);
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 result = (bool)(arg1)->AppendCols(arg2);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 {
8833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8834 }
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj = 0;
8843 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8844 size_t arg2 = (size_t) 0 ;
8845 size_t arg3 = (size_t) 1 ;
8846 bool result;
8847 void *argp1 = 0 ;
8848 int res1 = 0 ;
8849 size_t val2 ;
8850 int ecode2 = 0 ;
8851 size_t val3 ;
8852 int ecode3 = 0 ;
8853 PyObject * obj0 = 0 ;
8854 PyObject * obj1 = 0 ;
8855 PyObject * obj2 = 0 ;
8856 char * kwnames[] = {
8857 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8858 };
8859
8860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8862 if (!SWIG_IsOK(res1)) {
8863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8864 }
8865 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8866 if (obj1) {
8867 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8868 if (!SWIG_IsOK(ecode2)) {
8869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8870 }
8871 arg2 = static_cast< size_t >(val2);
8872 }
8873 if (obj2) {
8874 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8875 if (!SWIG_IsOK(ecode3)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8877 }
8878 arg3 = static_cast< size_t >(val3);
8879 }
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8883 wxPyEndAllowThreads(__tstate);
8884 if (PyErr_Occurred()) SWIG_fail;
8885 }
8886 {
8887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8888 }
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj = 0;
8897 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8898 int arg2 ;
8899 wxString result;
8900 void *argp1 = 0 ;
8901 int res1 = 0 ;
8902 int val2 ;
8903 int ecode2 = 0 ;
8904 PyObject * obj0 = 0 ;
8905 PyObject * obj1 = 0 ;
8906 char * kwnames[] = {
8907 (char *) "self",(char *) "row", NULL
8908 };
8909
8910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8912 if (!SWIG_IsOK(res1)) {
8913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8914 }
8915 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8916 ecode2 = SWIG_AsVal_int(obj1, &val2);
8917 if (!SWIG_IsOK(ecode2)) {
8918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8919 }
8920 arg2 = static_cast< int >(val2);
8921 {
8922 PyThreadState* __tstate = wxPyBeginAllowThreads();
8923 result = (arg1)->GetRowLabelValue(arg2);
8924 wxPyEndAllowThreads(__tstate);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 {
8928 #if wxUSE_UNICODE
8929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8930 #else
8931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8932 #endif
8933 }
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj = 0;
8942 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8943 int arg2 ;
8944 wxString result;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 int val2 ;
8948 int ecode2 = 0 ;
8949 PyObject * obj0 = 0 ;
8950 PyObject * obj1 = 0 ;
8951 char * kwnames[] = {
8952 (char *) "self",(char *) "col", NULL
8953 };
8954
8955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8959 }
8960 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8961 ecode2 = SWIG_AsVal_int(obj1, &val2);
8962 if (!SWIG_IsOK(ecode2)) {
8963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8964 }
8965 arg2 = static_cast< int >(val2);
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (arg1)->GetColLabelValue(arg2);
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 {
8973 #if wxUSE_UNICODE
8974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8975 #else
8976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8977 #endif
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8988 int arg2 ;
8989 wxString *arg3 = 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 int val2 ;
8993 int ecode2 = 0 ;
8994 bool temp3 = false ;
8995 PyObject * obj0 = 0 ;
8996 PyObject * obj1 = 0 ;
8997 PyObject * obj2 = 0 ;
8998 char * kwnames[] = {
8999 (char *) "self",(char *) "row",(char *) "value", NULL
9000 };
9001
9002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9006 }
9007 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9008 ecode2 = SWIG_AsVal_int(obj1, &val2);
9009 if (!SWIG_IsOK(ecode2)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9011 }
9012 arg2 = static_cast< int >(val2);
9013 {
9014 arg3 = wxString_in_helper(obj2);
9015 if (arg3 == NULL) SWIG_fail;
9016 temp3 = true;
9017 }
9018 {
9019 PyThreadState* __tstate = wxPyBeginAllowThreads();
9020 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 resultobj = SWIG_Py_Void();
9025 {
9026 if (temp3)
9027 delete arg3;
9028 }
9029 return resultobj;
9030 fail:
9031 {
9032 if (temp3)
9033 delete arg3;
9034 }
9035 return NULL;
9036 }
9037
9038
9039 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj = 0;
9041 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9042 int arg2 ;
9043 wxString *arg3 = 0 ;
9044 void *argp1 = 0 ;
9045 int res1 = 0 ;
9046 int val2 ;
9047 int ecode2 = 0 ;
9048 bool temp3 = false ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 PyObject * obj2 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "self",(char *) "col",(char *) "value", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9060 }
9061 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9062 ecode2 = SWIG_AsVal_int(obj1, &val2);
9063 if (!SWIG_IsOK(ecode2)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9065 }
9066 arg2 = static_cast< int >(val2);
9067 {
9068 arg3 = wxString_in_helper(obj2);
9069 if (arg3 == NULL) SWIG_fail;
9070 temp3 = true;
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 resultobj = SWIG_Py_Void();
9079 {
9080 if (temp3)
9081 delete arg3;
9082 }
9083 return resultobj;
9084 fail:
9085 {
9086 if (temp3)
9087 delete arg3;
9088 }
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 PyObject *resultobj = 0;
9095 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9096 bool result;
9097 void *argp1 = 0 ;
9098 int res1 = 0 ;
9099 PyObject *swig_obj[1] ;
9100
9101 if (!args) SWIG_fail;
9102 swig_obj[0] = args;
9103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9104 if (!SWIG_IsOK(res1)) {
9105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9106 }
9107 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 result = (bool)(arg1)->CanHaveAttributes();
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 {
9115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9116 }
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj = 0;
9125 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9126 int arg2 ;
9127 int arg3 ;
9128 wxGridCellAttr::wxAttrKind arg4 ;
9129 wxGridCellAttr *result = 0 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 int val2 ;
9133 int ecode2 = 0 ;
9134 int val3 ;
9135 int ecode3 = 0 ;
9136 int val4 ;
9137 int ecode4 = 0 ;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 PyObject * obj2 = 0 ;
9141 PyObject * obj3 = 0 ;
9142 char * kwnames[] = {
9143 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9144 };
9145
9146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9150 }
9151 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9152 ecode2 = SWIG_AsVal_int(obj1, &val2);
9153 if (!SWIG_IsOK(ecode2)) {
9154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9155 }
9156 arg2 = static_cast< int >(val2);
9157 ecode3 = SWIG_AsVal_int(obj2, &val3);
9158 if (!SWIG_IsOK(ecode3)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9160 }
9161 arg3 = static_cast< int >(val3);
9162 ecode4 = SWIG_AsVal_int(obj3, &val4);
9163 if (!SWIG_IsOK(ecode4)) {
9164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9165 }
9166 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 {
9174 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9175 }
9176 return resultobj;
9177 fail:
9178 return NULL;
9179 }
9180
9181
9182 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj = 0;
9184 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9185 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9186 int arg3 ;
9187 int arg4 ;
9188 void *argp1 = 0 ;
9189 int res1 = 0 ;
9190 void *argp2 = 0 ;
9191 int res2 = 0 ;
9192 int val3 ;
9193 int ecode3 = 0 ;
9194 int val4 ;
9195 int ecode4 = 0 ;
9196 PyObject * obj0 = 0 ;
9197 PyObject * obj1 = 0 ;
9198 PyObject * obj2 = 0 ;
9199 PyObject * obj3 = 0 ;
9200 char * kwnames[] = {
9201 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9202 };
9203
9204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9206 if (!SWIG_IsOK(res1)) {
9207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9208 }
9209 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9211 if (!SWIG_IsOK(res2)) {
9212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9213 }
9214 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9215 ecode3 = SWIG_AsVal_int(obj2, &val3);
9216 if (!SWIG_IsOK(ecode3)) {
9217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9218 }
9219 arg3 = static_cast< int >(val3);
9220 ecode4 = SWIG_AsVal_int(obj3, &val4);
9221 if (!SWIG_IsOK(ecode4)) {
9222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9223 }
9224 arg4 = static_cast< int >(val4);
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 (arg1)->SetAttr(arg2,arg3,arg4);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_Py_Void();
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj = 0;
9240 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9241 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9242 int arg3 ;
9243 void *argp1 = 0 ;
9244 int res1 = 0 ;
9245 void *argp2 = 0 ;
9246 int res2 = 0 ;
9247 int val3 ;
9248 int ecode3 = 0 ;
9249 PyObject * obj0 = 0 ;
9250 PyObject * obj1 = 0 ;
9251 PyObject * obj2 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "attr",(char *) "row", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9260 }
9261 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9263 if (!SWIG_IsOK(res2)) {
9264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9265 }
9266 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9267 ecode3 = SWIG_AsVal_int(obj2, &val3);
9268 if (!SWIG_IsOK(ecode3)) {
9269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9270 }
9271 arg3 = static_cast< int >(val3);
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 (arg1)->SetRowAttr(arg2,arg3);
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_Py_Void();
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj = 0;
9287 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9288 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9289 int arg3 ;
9290 void *argp1 = 0 ;
9291 int res1 = 0 ;
9292 void *argp2 = 0 ;
9293 int res2 = 0 ;
9294 int val3 ;
9295 int ecode3 = 0 ;
9296 PyObject * obj0 = 0 ;
9297 PyObject * obj1 = 0 ;
9298 PyObject * obj2 = 0 ;
9299 char * kwnames[] = {
9300 (char *) "self",(char *) "attr",(char *) "col", NULL
9301 };
9302
9303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9307 }
9308 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9310 if (!SWIG_IsOK(res2)) {
9311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9312 }
9313 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9314 ecode3 = SWIG_AsVal_int(obj2, &val3);
9315 if (!SWIG_IsOK(ecode3)) {
9316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9317 }
9318 arg3 = static_cast< int >(val3);
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->SetColAttr(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *obj;
9334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9335 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9336 return SWIG_Py_Void();
9337 }
9338
9339 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyGridTableBase *result = 0 ;
9342
9343 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj = 0;
9359 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9360 PyObject *arg2 = (PyObject *) 0 ;
9361 PyObject *arg3 = (PyObject *) 0 ;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject * obj0 = 0 ;
9365 PyObject * obj1 = 0 ;
9366 PyObject * obj2 = 0 ;
9367 char * kwnames[] = {
9368 (char *) "self",(char *) "self",(char *) "_class", NULL
9369 };
9370
9371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9375 }
9376 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9377 arg2 = obj1;
9378 arg3 = obj2;
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 (arg1)->_setCallbackInfo(arg2,arg3);
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 resultobj = SWIG_Py_Void();
9386 return resultobj;
9387 fail:
9388 return NULL;
9389 }
9390
9391
9392 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9393 PyObject *resultobj = 0;
9394 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9395 void *argp1 = 0 ;
9396 int res1 = 0 ;
9397 PyObject *swig_obj[1] ;
9398
9399 if (!args) SWIG_fail;
9400 swig_obj[0] = args;
9401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9402 if (!SWIG_IsOK(res1)) {
9403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9404 }
9405 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 wxPyGridTableBase_Destroy(arg1);
9409 wxPyEndAllowThreads(__tstate);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *obj;
9421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9422 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9423 return SWIG_Py_Void();
9424 }
9425
9426 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 return SWIG_Python_InitShadowInstance(args);
9428 }
9429
9430 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 int arg1 = (int) 0 ;
9433 int arg2 = (int) 0 ;
9434 wxGridStringTable *result = 0 ;
9435 int val1 ;
9436 int ecode1 = 0 ;
9437 int val2 ;
9438 int ecode2 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "numRows",(char *) "numCols", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9446 if (obj0) {
9447 ecode1 = SWIG_AsVal_int(obj0, &val1);
9448 if (!SWIG_IsOK(ecode1)) {
9449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9450 }
9451 arg1 = static_cast< int >(val1);
9452 }
9453 if (obj1) {
9454 ecode2 = SWIG_AsVal_int(obj1, &val2);
9455 if (!SWIG_IsOK(ecode2)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9457 }
9458 arg2 = static_cast< int >(val2);
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *obj;
9475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9476 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9477 return SWIG_Py_Void();
9478 }
9479
9480 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 return SWIG_Python_InitShadowInstance(args);
9482 }
9483
9484 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9487 int arg2 ;
9488 int arg3 = (int) -1 ;
9489 int arg4 = (int) -1 ;
9490 wxGridTableMessage *result = 0 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 int val2 ;
9494 int ecode2 = 0 ;
9495 int val3 ;
9496 int ecode3 = 0 ;
9497 int val4 ;
9498 int ecode4 = 0 ;
9499 PyObject * obj0 = 0 ;
9500 PyObject * obj1 = 0 ;
9501 PyObject * obj2 = 0 ;
9502 PyObject * obj3 = 0 ;
9503 char * kwnames[] = {
9504 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9505 };
9506
9507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9509 if (!SWIG_IsOK(res1)) {
9510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9511 }
9512 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9513 ecode2 = SWIG_AsVal_int(obj1, &val2);
9514 if (!SWIG_IsOK(ecode2)) {
9515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9516 }
9517 arg2 = static_cast< int >(val2);
9518 if (obj2) {
9519 ecode3 = SWIG_AsVal_int(obj2, &val3);
9520 if (!SWIG_IsOK(ecode3)) {
9521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9522 }
9523 arg3 = static_cast< int >(val3);
9524 }
9525 if (obj3) {
9526 ecode4 = SWIG_AsVal_int(obj3, &val4);
9527 if (!SWIG_IsOK(ecode4)) {
9528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9529 }
9530 arg4 = static_cast< int >(val4);
9531 }
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9546 PyObject *resultobj = 0;
9547 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 PyObject *swig_obj[1] ;
9551
9552 if (!args) SWIG_fail;
9553 swig_obj[0] = args;
9554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9557 }
9558 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 delete arg1;
9562
9563 wxPyEndAllowThreads(__tstate);
9564 if (PyErr_Occurred()) SWIG_fail;
9565 }
9566 resultobj = SWIG_Py_Void();
9567 return resultobj;
9568 fail:
9569 return NULL;
9570 }
9571
9572
9573 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9574 PyObject *resultobj = 0;
9575 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9576 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9577 void *argp1 = 0 ;
9578 int res1 = 0 ;
9579 void *argp2 = 0 ;
9580 int res2 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "table", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9591 }
9592 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9594 if (!SWIG_IsOK(res2)) {
9595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9596 }
9597 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->SetTableObject(arg2);
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9614 wxGridTableBase *result = 0 ;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9624 }
9625 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 {
9633 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9634 }
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj = 0;
9643 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9644 int arg2 ;
9645 void *argp1 = 0 ;
9646 int res1 = 0 ;
9647 int val2 ;
9648 int ecode2 = 0 ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 char * kwnames[] = {
9652 (char *) "self",(char *) "id", NULL
9653 };
9654
9655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9659 }
9660 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9661 ecode2 = SWIG_AsVal_int(obj1, &val2);
9662 if (!SWIG_IsOK(ecode2)) {
9663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9664 }
9665 arg2 = static_cast< int >(val2);
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 (arg1)->SetId(arg2);
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 resultobj = SWIG_Py_Void();
9673 return resultobj;
9674 fail:
9675 return NULL;
9676 }
9677
9678
9679 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9680 PyObject *resultobj = 0;
9681 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9682 int result;
9683 void *argp1 = 0 ;
9684 int res1 = 0 ;
9685 PyObject *swig_obj[1] ;
9686
9687 if (!args) SWIG_fail;
9688 swig_obj[0] = args;
9689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9692 }
9693 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 result = (int)(arg1)->GetId();
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_From_int(static_cast< int >(result));
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj = 0;
9709 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9710 int arg2 ;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 int val2 ;
9714 int ecode2 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 char * kwnames[] = {
9718 (char *) "self",(char *) "comInt1", NULL
9719 };
9720
9721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9723 if (!SWIG_IsOK(res1)) {
9724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9725 }
9726 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9727 ecode2 = SWIG_AsVal_int(obj1, &val2);
9728 if (!SWIG_IsOK(ecode2)) {
9729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9730 }
9731 arg2 = static_cast< int >(val2);
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 (arg1)->SetCommandInt(arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9748 int result;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9758 }
9759 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = (int)(arg1)->GetCommandInt();
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_From_int(static_cast< int >(result));
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9776 int arg2 ;
9777 void *argp1 = 0 ;
9778 int res1 = 0 ;
9779 int val2 ;
9780 int ecode2 = 0 ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 char * kwnames[] = {
9784 (char *) "self",(char *) "comInt2", NULL
9785 };
9786
9787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9791 }
9792 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9793 ecode2 = SWIG_AsVal_int(obj1, &val2);
9794 if (!SWIG_IsOK(ecode2)) {
9795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9796 }
9797 arg2 = static_cast< int >(val2);
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 (arg1)->SetCommandInt2(arg2);
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9812 PyObject *resultobj = 0;
9813 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9814 int result;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 PyObject *swig_obj[1] ;
9818
9819 if (!args) SWIG_fail;
9820 swig_obj[0] = args;
9821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9822 if (!SWIG_IsOK(res1)) {
9823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9824 }
9825 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (int)(arg1)->GetCommandInt2();
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_From_int(static_cast< int >(result));
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *obj;
9841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9842 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9843 return SWIG_Py_Void();
9844 }
9845
9846 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 return SWIG_Python_InitShadowInstance(args);
9848 }
9849
9850 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = 0;
9852 int arg1 = (int) -1 ;
9853 int arg2 = (int) -1 ;
9854 wxGridCellCoords *result = 0 ;
9855 int val1 ;
9856 int ecode1 = 0 ;
9857 int val2 ;
9858 int ecode2 = 0 ;
9859 PyObject * obj0 = 0 ;
9860 PyObject * obj1 = 0 ;
9861 char * kwnames[] = {
9862 (char *) "r",(char *) "c", NULL
9863 };
9864
9865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9866 if (obj0) {
9867 ecode1 = SWIG_AsVal_int(obj0, &val1);
9868 if (!SWIG_IsOK(ecode1)) {
9869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9870 }
9871 arg1 = static_cast< int >(val1);
9872 }
9873 if (obj1) {
9874 ecode2 = SWIG_AsVal_int(obj1, &val2);
9875 if (!SWIG_IsOK(ecode2)) {
9876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9877 }
9878 arg2 = static_cast< int >(val2);
9879 }
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *resultobj = 0;
9895 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9905 }
9906 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 delete arg1;
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_Py_Void();
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 PyObject *resultobj = 0;
9923 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9924 int result;
9925 void *argp1 = 0 ;
9926 int res1 = 0 ;
9927 PyObject *swig_obj[1] ;
9928
9929 if (!args) SWIG_fail;
9930 swig_obj[0] = args;
9931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9932 if (!SWIG_IsOK(res1)) {
9933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9934 }
9935 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9936 {
9937 PyThreadState* __tstate = wxPyBeginAllowThreads();
9938 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9939 wxPyEndAllowThreads(__tstate);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_From_int(static_cast< int >(result));
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9950 PyObject *resultobj = 0;
9951 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9952 int arg2 ;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 int val2 ;
9956 int ecode2 = 0 ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 char * kwnames[] = {
9960 (char *) "self",(char *) "n", NULL
9961 };
9962
9963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9965 if (!SWIG_IsOK(res1)) {
9966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9967 }
9968 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9969 ecode2 = SWIG_AsVal_int(obj1, &val2);
9970 if (!SWIG_IsOK(ecode2)) {
9971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9972 }
9973 arg2 = static_cast< int >(val2);
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 (arg1)->SetRow(arg2);
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_Py_Void();
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988 PyObject *resultobj = 0;
9989 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9990 int result;
9991 void *argp1 = 0 ;
9992 int res1 = 0 ;
9993 PyObject *swig_obj[1] ;
9994
9995 if (!args) SWIG_fail;
9996 swig_obj[0] = args;
9997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10000 }
10001 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 resultobj = SWIG_From_int(static_cast< int >(result));
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10016 PyObject *resultobj = 0;
10017 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10018 int arg2 ;
10019 void *argp1 = 0 ;
10020 int res1 = 0 ;
10021 int val2 ;
10022 int ecode2 = 0 ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char * kwnames[] = {
10026 (char *) "self",(char *) "n", NULL
10027 };
10028
10029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10033 }
10034 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10035 ecode2 = SWIG_AsVal_int(obj1, &val2);
10036 if (!SWIG_IsOK(ecode2)) {
10037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10038 }
10039 arg2 = static_cast< int >(val2);
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 (arg1)->SetCol(arg2);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_Py_Void();
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10056 int arg2 ;
10057 int arg3 ;
10058 void *argp1 = 0 ;
10059 int res1 = 0 ;
10060 int val2 ;
10061 int ecode2 = 0 ;
10062 int val3 ;
10063 int ecode3 = 0 ;
10064 PyObject * obj0 = 0 ;
10065 PyObject * obj1 = 0 ;
10066 PyObject * obj2 = 0 ;
10067 char * kwnames[] = {
10068 (char *) "self",(char *) "row",(char *) "col", NULL
10069 };
10070
10071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10073 if (!SWIG_IsOK(res1)) {
10074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10075 }
10076 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10077 ecode2 = SWIG_AsVal_int(obj1, &val2);
10078 if (!SWIG_IsOK(ecode2)) {
10079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10080 }
10081 arg2 = static_cast< int >(val2);
10082 ecode3 = SWIG_AsVal_int(obj2, &val3);
10083 if (!SWIG_IsOK(ecode3)) {
10084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10085 }
10086 arg3 = static_cast< int >(val3);
10087 {
10088 PyThreadState* __tstate = wxPyBeginAllowThreads();
10089 (arg1)->Set(arg2,arg3);
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 resultobj = SWIG_Py_Void();
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj = 0;
10102 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10103 PyObject *arg2 = (PyObject *) 0 ;
10104 bool result;
10105 void *argp1 = 0 ;
10106 int res1 = 0 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char * kwnames[] = {
10110 (char *) "self",(char *) "other", NULL
10111 };
10112
10113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10117 }
10118 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10119 arg2 = obj1;
10120 {
10121 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10136 PyObject *arg2 = (PyObject *) 0 ;
10137 bool result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 char * kwnames[] = {
10143 (char *) "self",(char *) "other", NULL
10144 };
10145
10146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10150 }
10151 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10152 arg2 = obj1;
10153 {
10154 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 {
10158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10159 }
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167 PyObject *resultobj = 0;
10168 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10169 PyObject *result = 0 ;
10170 void *argp1 = 0 ;
10171 int res1 = 0 ;
10172 PyObject *swig_obj[1] ;
10173
10174 if (!args) SWIG_fail;
10175 swig_obj[0] = args;
10176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10179 }
10180 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10181 {
10182 PyThreadState* __tstate = wxPyBeginAllowThreads();
10183 result = (PyObject *)wxGridCellCoords_Get(arg1);
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = result;
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10195 PyObject *obj;
10196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10197 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10198 return SWIG_Py_Void();
10199 }
10200
10201 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 return SWIG_Python_InitShadowInstance(args);
10203 }
10204
10205 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj = 0;
10207 wxWindow *arg1 = (wxWindow *) 0 ;
10208 int arg2 = (int) -1 ;
10209 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10210 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10211 wxSize const &arg4_defvalue = wxDefaultSize ;
10212 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10213 long arg5 = (long) wxWANTS_CHARS ;
10214 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10215 wxString *arg6 = (wxString *) &arg6_defvalue ;
10216 wxGrid *result = 0 ;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 int val2 ;
10220 int ecode2 = 0 ;
10221 wxPoint temp3 ;
10222 wxSize temp4 ;
10223 long val5 ;
10224 int ecode5 = 0 ;
10225 bool temp6 = false ;
10226 PyObject * obj0 = 0 ;
10227 PyObject * obj1 = 0 ;
10228 PyObject * obj2 = 0 ;
10229 PyObject * obj3 = 0 ;
10230 PyObject * obj4 = 0 ;
10231 PyObject * obj5 = 0 ;
10232 char * kwnames[] = {
10233 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10234 };
10235
10236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10238 if (!SWIG_IsOK(res1)) {
10239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10240 }
10241 arg1 = reinterpret_cast< wxWindow * >(argp1);
10242 if (obj1) {
10243 ecode2 = SWIG_AsVal_int(obj1, &val2);
10244 if (!SWIG_IsOK(ecode2)) {
10245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10246 }
10247 arg2 = static_cast< int >(val2);
10248 }
10249 if (obj2) {
10250 {
10251 arg3 = &temp3;
10252 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10253 }
10254 }
10255 if (obj3) {
10256 {
10257 arg4 = &temp4;
10258 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10259 }
10260 }
10261 if (obj4) {
10262 ecode5 = SWIG_AsVal_long(obj4, &val5);
10263 if (!SWIG_IsOK(ecode5)) {
10264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10265 }
10266 arg5 = static_cast< long >(val5);
10267 }
10268 if (obj5) {
10269 {
10270 arg6 = wxString_in_helper(obj5);
10271 if (arg6 == NULL) SWIG_fail;
10272 temp6 = true;
10273 }
10274 }
10275 {
10276 if (!wxPyCheckForApp()) SWIG_fail;
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10283 {
10284 if (temp6)
10285 delete arg6;
10286 }
10287 return resultobj;
10288 fail:
10289 {
10290 if (temp6)
10291 delete arg6;
10292 }
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10298 PyObject *resultobj = 0;
10299 wxGrid *result = 0 ;
10300
10301 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10302 {
10303 if (!wxPyCheckForApp()) SWIG_fail;
10304 PyThreadState* __tstate = wxPyBeginAllowThreads();
10305 result = (wxGrid *)new wxGrid();
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10317 PyObject *resultobj = 0;
10318 wxGrid *arg1 = (wxGrid *) 0 ;
10319 wxWindow *arg2 = (wxWindow *) 0 ;
10320 int arg3 = (int) -1 ;
10321 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10322 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10323 wxSize const &arg5_defvalue = wxDefaultSize ;
10324 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10325 long arg6 = (long) wxWANTS_CHARS ;
10326 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10327 wxString *arg7 = (wxString *) &arg7_defvalue ;
10328 bool result;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 void *argp2 = 0 ;
10332 int res2 = 0 ;
10333 int val3 ;
10334 int ecode3 = 0 ;
10335 wxPoint temp4 ;
10336 wxSize temp5 ;
10337 long val6 ;
10338 int ecode6 = 0 ;
10339 bool temp7 = false ;
10340 PyObject * obj0 = 0 ;
10341 PyObject * obj1 = 0 ;
10342 PyObject * obj2 = 0 ;
10343 PyObject * obj3 = 0 ;
10344 PyObject * obj4 = 0 ;
10345 PyObject * obj5 = 0 ;
10346 PyObject * obj6 = 0 ;
10347 char * kwnames[] = {
10348 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10349 };
10350
10351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10353 if (!SWIG_IsOK(res1)) {
10354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10355 }
10356 arg1 = reinterpret_cast< wxGrid * >(argp1);
10357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10358 if (!SWIG_IsOK(res2)) {
10359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10360 }
10361 arg2 = reinterpret_cast< wxWindow * >(argp2);
10362 if (obj2) {
10363 ecode3 = SWIG_AsVal_int(obj2, &val3);
10364 if (!SWIG_IsOK(ecode3)) {
10365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10366 }
10367 arg3 = static_cast< int >(val3);
10368 }
10369 if (obj3) {
10370 {
10371 arg4 = &temp4;
10372 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10373 }
10374 }
10375 if (obj4) {
10376 {
10377 arg5 = &temp5;
10378 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10379 }
10380 }
10381 if (obj5) {
10382 ecode6 = SWIG_AsVal_long(obj5, &val6);
10383 if (!SWIG_IsOK(ecode6)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10385 }
10386 arg6 = static_cast< long >(val6);
10387 }
10388 if (obj6) {
10389 {
10390 arg7 = wxString_in_helper(obj6);
10391 if (arg7 == NULL) SWIG_fail;
10392 temp7 = true;
10393 }
10394 }
10395 {
10396 PyThreadState* __tstate = wxPyBeginAllowThreads();
10397 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 {
10402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10403 }
10404 {
10405 if (temp7)
10406 delete arg7;
10407 }
10408 return resultobj;
10409 fail:
10410 {
10411 if (temp7)
10412 delete arg7;
10413 }
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj = 0;
10420 wxGrid *arg1 = (wxGrid *) 0 ;
10421 int arg2 ;
10422 int arg3 ;
10423 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10424 bool result;
10425 void *argp1 = 0 ;
10426 int res1 = 0 ;
10427 int val2 ;
10428 int ecode2 = 0 ;
10429 int val3 ;
10430 int ecode3 = 0 ;
10431 int val4 ;
10432 int ecode4 = 0 ;
10433 PyObject * obj0 = 0 ;
10434 PyObject * obj1 = 0 ;
10435 PyObject * obj2 = 0 ;
10436 PyObject * obj3 = 0 ;
10437 char * kwnames[] = {
10438 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10439 };
10440
10441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10443 if (!SWIG_IsOK(res1)) {
10444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10445 }
10446 arg1 = reinterpret_cast< wxGrid * >(argp1);
10447 ecode2 = SWIG_AsVal_int(obj1, &val2);
10448 if (!SWIG_IsOK(ecode2)) {
10449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10450 }
10451 arg2 = static_cast< int >(val2);
10452 ecode3 = SWIG_AsVal_int(obj2, &val3);
10453 if (!SWIG_IsOK(ecode3)) {
10454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10455 }
10456 arg3 = static_cast< int >(val3);
10457 if (obj3) {
10458 ecode4 = SWIG_AsVal_int(obj3, &val4);
10459 if (!SWIG_IsOK(ecode4)) {
10460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10461 }
10462 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10472 }
10473 return resultobj;
10474 fail:
10475 return NULL;
10476 }
10477
10478
10479 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj = 0;
10481 wxGrid *arg1 = (wxGrid *) 0 ;
10482 WXGRIDSELECTIONMODES arg2 ;
10483 void *argp1 = 0 ;
10484 int res1 = 0 ;
10485 int val2 ;
10486 int ecode2 = 0 ;
10487 PyObject * obj0 = 0 ;
10488 PyObject * obj1 = 0 ;
10489 char * kwnames[] = {
10490 (char *) "self",(char *) "selmode", NULL
10491 };
10492
10493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10497 }
10498 arg1 = reinterpret_cast< wxGrid * >(argp1);
10499 ecode2 = SWIG_AsVal_int(obj1, &val2);
10500 if (!SWIG_IsOK(ecode2)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10502 }
10503 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 (arg1)->SetSelectionMode(arg2);
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_Py_Void();
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10518 PyObject *resultobj = 0;
10519 wxGrid *arg1 = (wxGrid *) 0 ;
10520 WXGRIDSELECTIONMODES result;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 PyObject *swig_obj[1] ;
10524
10525 if (!args) SWIG_fail;
10526 swig_obj[0] = args;
10527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10528 if (!SWIG_IsOK(res1)) {
10529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10530 }
10531 arg1 = reinterpret_cast< wxGrid * >(argp1);
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 resultobj = SWIG_From_int(static_cast< int >(result));
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10546 PyObject *resultobj = 0;
10547 wxGrid *arg1 = (wxGrid *) 0 ;
10548 int result;
10549 void *argp1 = 0 ;
10550 int res1 = 0 ;
10551 PyObject *swig_obj[1] ;
10552
10553 if (!args) SWIG_fail;
10554 swig_obj[0] = args;
10555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10556 if (!SWIG_IsOK(res1)) {
10557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10558 }
10559 arg1 = reinterpret_cast< wxGrid * >(argp1);
10560 {
10561 PyThreadState* __tstate = wxPyBeginAllowThreads();
10562 result = (int)(arg1)->GetNumberRows();
10563 wxPyEndAllowThreads(__tstate);
10564 if (PyErr_Occurred()) SWIG_fail;
10565 }
10566 resultobj = SWIG_From_int(static_cast< int >(result));
10567 return resultobj;
10568 fail:
10569 return NULL;
10570 }
10571
10572
10573 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10574 PyObject *resultobj = 0;
10575 wxGrid *arg1 = (wxGrid *) 0 ;
10576 int result;
10577 void *argp1 = 0 ;
10578 int res1 = 0 ;
10579 PyObject *swig_obj[1] ;
10580
10581 if (!args) SWIG_fail;
10582 swig_obj[0] = args;
10583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10584 if (!SWIG_IsOK(res1)) {
10585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10586 }
10587 arg1 = reinterpret_cast< wxGrid * >(argp1);
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (int)(arg1)->GetNumberCols();
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 resultobj = SWIG_From_int(static_cast< int >(result));
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj = 0;
10603 wxGrid *arg1 = (wxGrid *) 0 ;
10604 wxGridTableMessage *arg2 = 0 ;
10605 bool result;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 void *argp2 = 0 ;
10609 int res2 = 0 ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 char * kwnames[] = {
10613 (char *) "self",(char *)"arg2", NULL
10614 };
10615
10616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10618 if (!SWIG_IsOK(res1)) {
10619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10620 }
10621 arg1 = reinterpret_cast< wxGrid * >(argp1);
10622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10623 if (!SWIG_IsOK(res2)) {
10624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10625 }
10626 if (!argp2) {
10627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10628 }
10629 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10638 }
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxGrid *arg1 = (wxGrid *) 0 ;
10648 wxGridTableBase *result = 0 ;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 PyObject *swig_obj[1] ;
10652
10653 if (!args) SWIG_fail;
10654 swig_obj[0] = args;
10655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10656 if (!SWIG_IsOK(res1)) {
10657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10658 }
10659 arg1 = reinterpret_cast< wxGrid * >(argp1);
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 {
10667 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10668 }
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxGrid *arg1 = (wxGrid *) 0 ;
10678 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10679 bool arg3 = (bool) false ;
10680 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10681 bool result;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 int res2 = 0 ;
10685 bool val3 ;
10686 int ecode3 = 0 ;
10687 int val4 ;
10688 int ecode4 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 PyObject * obj3 = 0 ;
10693 char * kwnames[] = {
10694 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10695 };
10696
10697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10699 if (!SWIG_IsOK(res1)) {
10700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10701 }
10702 arg1 = reinterpret_cast< wxGrid * >(argp1);
10703 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10704 if (!SWIG_IsOK(res2)) {
10705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10706 }
10707 if (obj2) {
10708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10709 if (!SWIG_IsOK(ecode3)) {
10710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10711 }
10712 arg3 = static_cast< bool >(val3);
10713 }
10714 if (obj3) {
10715 ecode4 = SWIG_AsVal_int(obj3, &val4);
10716 if (!SWIG_IsOK(ecode4)) {
10717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10718 }
10719 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10720 }
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10729 }
10730 return resultobj;
10731 fail:
10732 return NULL;
10733 }
10734
10735
10736 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10737 PyObject *resultobj = 0;
10738 wxGrid *arg1 = (wxGrid *) 0 ;
10739 void *argp1 = 0 ;
10740 int res1 = 0 ;
10741 PyObject *swig_obj[1] ;
10742
10743 if (!args) SWIG_fail;
10744 swig_obj[0] = args;
10745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10746 if (!SWIG_IsOK(res1)) {
10747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10748 }
10749 arg1 = reinterpret_cast< wxGrid * >(argp1);
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->ClearGrid();
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10764 PyObject *resultobj = 0;
10765 wxGrid *arg1 = (wxGrid *) 0 ;
10766 int arg2 = (int) 0 ;
10767 int arg3 = (int) 1 ;
10768 bool arg4 = (bool) true ;
10769 bool result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 int val2 ;
10773 int ecode2 = 0 ;
10774 int val3 ;
10775 int ecode3 = 0 ;
10776 bool val4 ;
10777 int ecode4 = 0 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 PyObject * obj2 = 0 ;
10781 PyObject * obj3 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10790 }
10791 arg1 = reinterpret_cast< wxGrid * >(argp1);
10792 if (obj1) {
10793 ecode2 = SWIG_AsVal_int(obj1, &val2);
10794 if (!SWIG_IsOK(ecode2)) {
10795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10796 }
10797 arg2 = static_cast< int >(val2);
10798 }
10799 if (obj2) {
10800 ecode3 = SWIG_AsVal_int(obj2, &val3);
10801 if (!SWIG_IsOK(ecode3)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10803 }
10804 arg3 = static_cast< int >(val3);
10805 }
10806 if (obj3) {
10807 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10808 if (!SWIG_IsOK(ecode4)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10810 }
10811 arg4 = static_cast< bool >(val4);
10812 }
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10821 }
10822 return resultobj;
10823 fail:
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10829 PyObject *resultobj = 0;
10830 wxGrid *arg1 = (wxGrid *) 0 ;
10831 int arg2 = (int) 1 ;
10832 bool arg3 = (bool) true ;
10833 bool result;
10834 void *argp1 = 0 ;
10835 int res1 = 0 ;
10836 int val2 ;
10837 int ecode2 = 0 ;
10838 bool val3 ;
10839 int ecode3 = 0 ;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char * kwnames[] = {
10844 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10845 };
10846
10847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10849 if (!SWIG_IsOK(res1)) {
10850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10851 }
10852 arg1 = reinterpret_cast< wxGrid * >(argp1);
10853 if (obj1) {
10854 ecode2 = SWIG_AsVal_int(obj1, &val2);
10855 if (!SWIG_IsOK(ecode2)) {
10856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10857 }
10858 arg2 = static_cast< int >(val2);
10859 }
10860 if (obj2) {
10861 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10862 if (!SWIG_IsOK(ecode3)) {
10863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10864 }
10865 arg3 = static_cast< bool >(val3);
10866 }
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 result = (bool)(arg1)->AppendRows(arg2,arg3);
10870 wxPyEndAllowThreads(__tstate);
10871 if (PyErr_Occurred()) SWIG_fail;
10872 }
10873 {
10874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10875 }
10876 return resultobj;
10877 fail:
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10883 PyObject *resultobj = 0;
10884 wxGrid *arg1 = (wxGrid *) 0 ;
10885 int arg2 = (int) 0 ;
10886 int arg3 = (int) 1 ;
10887 bool arg4 = (bool) true ;
10888 bool result;
10889 void *argp1 = 0 ;
10890 int res1 = 0 ;
10891 int val2 ;
10892 int ecode2 = 0 ;
10893 int val3 ;
10894 int ecode3 = 0 ;
10895 bool val4 ;
10896 int ecode4 = 0 ;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 PyObject * obj2 = 0 ;
10900 PyObject * obj3 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10909 }
10910 arg1 = reinterpret_cast< wxGrid * >(argp1);
10911 if (obj1) {
10912 ecode2 = SWIG_AsVal_int(obj1, &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 }
10918 if (obj2) {
10919 ecode3 = SWIG_AsVal_int(obj2, &val3);
10920 if (!SWIG_IsOK(ecode3)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10922 }
10923 arg3 = static_cast< int >(val3);
10924 }
10925 if (obj3) {
10926 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10927 if (!SWIG_IsOK(ecode4)) {
10928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10929 }
10930 arg4 = static_cast< bool >(val4);
10931 }
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10940 }
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxGrid *arg1 = (wxGrid *) 0 ;
10950 int arg2 = (int) 0 ;
10951 int arg3 = (int) 1 ;
10952 bool arg4 = (bool) true ;
10953 bool result;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int val2 ;
10957 int ecode2 = 0 ;
10958 int val3 ;
10959 int ecode3 = 0 ;
10960 bool val4 ;
10961 int ecode4 = 0 ;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 PyObject * obj3 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10974 }
10975 arg1 = reinterpret_cast< wxGrid * >(argp1);
10976 if (obj1) {
10977 ecode2 = SWIG_AsVal_int(obj1, &val2);
10978 if (!SWIG_IsOK(ecode2)) {
10979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10980 }
10981 arg2 = static_cast< int >(val2);
10982 }
10983 if (obj2) {
10984 ecode3 = SWIG_AsVal_int(obj2, &val3);
10985 if (!SWIG_IsOK(ecode3)) {
10986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10987 }
10988 arg3 = static_cast< int >(val3);
10989 }
10990 if (obj3) {
10991 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10992 if (!SWIG_IsOK(ecode4)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10994 }
10995 arg4 = static_cast< bool >(val4);
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj = 0;
11014 wxGrid *arg1 = (wxGrid *) 0 ;
11015 int arg2 = (int) 1 ;
11016 bool arg3 = (bool) true ;
11017 bool result;
11018 void *argp1 = 0 ;
11019 int res1 = 0 ;
11020 int val2 ;
11021 int ecode2 = 0 ;
11022 bool val3 ;
11023 int ecode3 = 0 ;
11024 PyObject * obj0 = 0 ;
11025 PyObject * obj1 = 0 ;
11026 PyObject * obj2 = 0 ;
11027 char * kwnames[] = {
11028 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11029 };
11030
11031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11033 if (!SWIG_IsOK(res1)) {
11034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11035 }
11036 arg1 = reinterpret_cast< wxGrid * >(argp1);
11037 if (obj1) {
11038 ecode2 = SWIG_AsVal_int(obj1, &val2);
11039 if (!SWIG_IsOK(ecode2)) {
11040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11041 }
11042 arg2 = static_cast< int >(val2);
11043 }
11044 if (obj2) {
11045 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11046 if (!SWIG_IsOK(ecode3)) {
11047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11048 }
11049 arg3 = static_cast< bool >(val3);
11050 }
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (bool)(arg1)->AppendCols(arg2,arg3);
11054 wxPyEndAllowThreads(__tstate);
11055 if (PyErr_Occurred()) SWIG_fail;
11056 }
11057 {
11058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11059 }
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj = 0;
11068 wxGrid *arg1 = (wxGrid *) 0 ;
11069 int arg2 = (int) 0 ;
11070 int arg3 = (int) 1 ;
11071 bool arg4 = (bool) true ;
11072 bool result;
11073 void *argp1 = 0 ;
11074 int res1 = 0 ;
11075 int val2 ;
11076 int ecode2 = 0 ;
11077 int val3 ;
11078 int ecode3 = 0 ;
11079 bool val4 ;
11080 int ecode4 = 0 ;
11081 PyObject * obj0 = 0 ;
11082 PyObject * obj1 = 0 ;
11083 PyObject * obj2 = 0 ;
11084 PyObject * obj3 = 0 ;
11085 char * kwnames[] = {
11086 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11087 };
11088
11089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11091 if (!SWIG_IsOK(res1)) {
11092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11093 }
11094 arg1 = reinterpret_cast< wxGrid * >(argp1);
11095 if (obj1) {
11096 ecode2 = SWIG_AsVal_int(obj1, &val2);
11097 if (!SWIG_IsOK(ecode2)) {
11098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11099 }
11100 arg2 = static_cast< int >(val2);
11101 }
11102 if (obj2) {
11103 ecode3 = SWIG_AsVal_int(obj2, &val3);
11104 if (!SWIG_IsOK(ecode3)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11106 }
11107 arg3 = static_cast< int >(val3);
11108 }
11109 if (obj3) {
11110 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11111 if (!SWIG_IsOK(ecode4)) {
11112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11113 }
11114 arg4 = static_cast< bool >(val4);
11115 }
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11119 wxPyEndAllowThreads(__tstate);
11120 if (PyErr_Occurred()) SWIG_fail;
11121 }
11122 {
11123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11124 }
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj = 0;
11133 wxGrid *arg1 = (wxGrid *) 0 ;
11134 wxDC *arg2 = 0 ;
11135 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11136 void *argp1 = 0 ;
11137 int res1 = 0 ;
11138 void *argp2 = 0 ;
11139 int res2 = 0 ;
11140 void *argp3 = 0 ;
11141 int res3 = 0 ;
11142 PyObject * obj0 = 0 ;
11143 PyObject * obj1 = 0 ;
11144 PyObject * obj2 = 0 ;
11145 char * kwnames[] = {
11146 (char *) "self",(char *) "dc",(char *) "attr", NULL
11147 };
11148
11149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11153 }
11154 arg1 = reinterpret_cast< wxGrid * >(argp1);
11155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11156 if (!SWIG_IsOK(res2)) {
11157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11158 }
11159 if (!argp2) {
11160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11161 }
11162 arg2 = reinterpret_cast< wxDC * >(argp2);
11163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11164 if (!SWIG_IsOK(res3)) {
11165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11166 }
11167 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 resultobj = SWIG_Py_Void();
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11182 PyObject *resultobj = 0;
11183 wxGrid *arg1 = (wxGrid *) 0 ;
11184 wxDC *arg2 = 0 ;
11185 wxString *arg3 = 0 ;
11186 wxRect *arg4 = 0 ;
11187 int arg5 = (int) wxLEFT ;
11188 int arg6 = (int) wxTOP ;
11189 int arg7 = (int) wxHORIZONTAL ;
11190 void *argp1 = 0 ;
11191 int res1 = 0 ;
11192 void *argp2 = 0 ;
11193 int res2 = 0 ;
11194 bool temp3 = false ;
11195 wxRect temp4 ;
11196 int val5 ;
11197 int ecode5 = 0 ;
11198 int val6 ;
11199 int ecode6 = 0 ;
11200 int val7 ;
11201 int ecode7 = 0 ;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 PyObject * obj3 = 0 ;
11206 PyObject * obj4 = 0 ;
11207 PyObject * obj5 = 0 ;
11208 PyObject * obj6 = 0 ;
11209 char * kwnames[] = {
11210 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11211 };
11212
11213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11215 if (!SWIG_IsOK(res1)) {
11216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11217 }
11218 arg1 = reinterpret_cast< wxGrid * >(argp1);
11219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11220 if (!SWIG_IsOK(res2)) {
11221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11222 }
11223 if (!argp2) {
11224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11225 }
11226 arg2 = reinterpret_cast< wxDC * >(argp2);
11227 {
11228 arg3 = wxString_in_helper(obj2);
11229 if (arg3 == NULL) SWIG_fail;
11230 temp3 = true;
11231 }
11232 {
11233 arg4 = &temp4;
11234 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11235 }
11236 if (obj4) {
11237 ecode5 = SWIG_AsVal_int(obj4, &val5);
11238 if (!SWIG_IsOK(ecode5)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11240 }
11241 arg5 = static_cast< int >(val5);
11242 }
11243 if (obj5) {
11244 ecode6 = SWIG_AsVal_int(obj5, &val6);
11245 if (!SWIG_IsOK(ecode6)) {
11246 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11247 }
11248 arg6 = static_cast< int >(val6);
11249 }
11250 if (obj6) {
11251 ecode7 = SWIG_AsVal_int(obj6, &val7);
11252 if (!SWIG_IsOK(ecode7)) {
11253 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11254 }
11255 arg7 = static_cast< int >(val7);
11256 }
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 resultobj = SWIG_Py_Void();
11264 {
11265 if (temp3)
11266 delete arg3;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (temp3)
11272 delete arg3;
11273 }
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = 0;
11280 wxGrid *arg1 = (wxGrid *) 0 ;
11281 wxDC *arg2 = 0 ;
11282 wxArrayString *arg3 = 0 ;
11283 long *arg4 = (long *) 0 ;
11284 long *arg5 = (long *) 0 ;
11285 void *argp1 = 0 ;
11286 int res1 = 0 ;
11287 void *argp2 = 0 ;
11288 int res2 = 0 ;
11289 bool temp3 = false ;
11290 long temp4 ;
11291 int res4 = SWIG_TMPOBJ ;
11292 long temp5 ;
11293 int res5 = SWIG_TMPOBJ ;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 PyObject * obj2 = 0 ;
11297 char * kwnames[] = {
11298 (char *) "self",(char *) "dc",(char *) "lines", NULL
11299 };
11300
11301 arg4 = &temp4;
11302 arg5 = &temp5;
11303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11307 }
11308 arg1 = reinterpret_cast< wxGrid * >(argp1);
11309 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11310 if (!SWIG_IsOK(res2)) {
11311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11312 }
11313 if (!argp2) {
11314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11315 }
11316 arg2 = reinterpret_cast< wxDC * >(argp2);
11317 {
11318 if (! PySequence_Check(obj2)) {
11319 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11320 SWIG_fail;
11321 }
11322 arg3 = new wxArrayString;
11323 temp3 = true;
11324 int i, len=PySequence_Length(obj2);
11325 for (i=0; i<len; i++) {
11326 PyObject* item = PySequence_GetItem(obj2, i);
11327 wxString* s = wxString_in_helper(item);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 arg3->Add(*s);
11330 delete s;
11331 Py_DECREF(item);
11332 }
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 if (SWIG_IsTmpObj(res4)) {
11342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11343 } else {
11344 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11346 }
11347 if (SWIG_IsTmpObj(res5)) {
11348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11349 } else {
11350 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11352 }
11353 {
11354 if (temp3) delete arg3;
11355 }
11356 return resultobj;
11357 fail:
11358 {
11359 if (temp3) delete arg3;
11360 }
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *resultobj = 0;
11367 wxGrid *arg1 = (wxGrid *) 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 PyObject *swig_obj[1] ;
11371
11372 if (!args) SWIG_fail;
11373 swig_obj[0] = args;
11374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11375 if (!SWIG_IsOK(res1)) {
11376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11377 }
11378 arg1 = reinterpret_cast< wxGrid * >(argp1);
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 (arg1)->BeginBatch();
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 resultobj = SWIG_Py_Void();
11386 return resultobj;
11387 fail:
11388 return NULL;
11389 }
11390
11391
11392 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393 PyObject *resultobj = 0;
11394 wxGrid *arg1 = (wxGrid *) 0 ;
11395 void *argp1 = 0 ;
11396 int res1 = 0 ;
11397 PyObject *swig_obj[1] ;
11398
11399 if (!args) SWIG_fail;
11400 swig_obj[0] = args;
11401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11402 if (!SWIG_IsOK(res1)) {
11403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11404 }
11405 arg1 = reinterpret_cast< wxGrid * >(argp1);
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 (arg1)->EndBatch();
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 resultobj = SWIG_Py_Void();
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *resultobj = 0;
11421 wxGrid *arg1 = (wxGrid *) 0 ;
11422 int result;
11423 void *argp1 = 0 ;
11424 int res1 = 0 ;
11425 PyObject *swig_obj[1] ;
11426
11427 if (!args) SWIG_fail;
11428 swig_obj[0] = args;
11429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11430 if (!SWIG_IsOK(res1)) {
11431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11432 }
11433 arg1 = reinterpret_cast< wxGrid * >(argp1);
11434 {
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 result = (int)(arg1)->GetBatchCount();
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 resultobj = SWIG_From_int(static_cast< int >(result));
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11448 PyObject *resultobj = 0;
11449 wxGrid *arg1 = (wxGrid *) 0 ;
11450 void *argp1 = 0 ;
11451 int res1 = 0 ;
11452 PyObject *swig_obj[1] ;
11453
11454 if (!args) SWIG_fail;
11455 swig_obj[0] = args;
11456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11457 if (!SWIG_IsOK(res1)) {
11458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11459 }
11460 arg1 = reinterpret_cast< wxGrid * >(argp1);
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 (arg1)->ForceRefresh();
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 resultobj = SWIG_Py_Void();
11468 return resultobj;
11469 fail:
11470 return NULL;
11471 }
11472
11473
11474 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11475 PyObject *resultobj = 0;
11476 wxGrid *arg1 = (wxGrid *) 0 ;
11477 bool result;
11478 void *argp1 = 0 ;
11479 int res1 = 0 ;
11480 PyObject *swig_obj[1] ;
11481
11482 if (!args) SWIG_fail;
11483 swig_obj[0] = args;
11484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11485 if (!SWIG_IsOK(res1)) {
11486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11487 }
11488 arg1 = reinterpret_cast< wxGrid * >(argp1);
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)(arg1)->IsEditable();
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11497 }
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj = 0;
11506 wxGrid *arg1 = (wxGrid *) 0 ;
11507 bool arg2 ;
11508 void *argp1 = 0 ;
11509 int res1 = 0 ;
11510 bool val2 ;
11511 int ecode2 = 0 ;
11512 PyObject * obj0 = 0 ;
11513 PyObject * obj1 = 0 ;
11514 char * kwnames[] = {
11515 (char *) "self",(char *) "edit", NULL
11516 };
11517
11518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11522 }
11523 arg1 = reinterpret_cast< wxGrid * >(argp1);
11524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11525 if (!SWIG_IsOK(ecode2)) {
11526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11527 }
11528 arg2 = static_cast< bool >(val2);
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->EnableEditing(arg2);
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 resultobj = SWIG_Py_Void();
11536 return resultobj;
11537 fail:
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11543 PyObject *resultobj = 0;
11544 wxGrid *arg1 = (wxGrid *) 0 ;
11545 bool arg2 = (bool) true ;
11546 void *argp1 = 0 ;
11547 int res1 = 0 ;
11548 bool val2 ;
11549 int ecode2 = 0 ;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "self",(char *) "enable", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11558 if (!SWIG_IsOK(res1)) {
11559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11560 }
11561 arg1 = reinterpret_cast< wxGrid * >(argp1);
11562 if (obj1) {
11563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11564 if (!SWIG_IsOK(ecode2)) {
11565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11566 }
11567 arg2 = static_cast< bool >(val2);
11568 }
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 (arg1)->EnableCellEditControl(arg2);
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 resultobj = SWIG_Py_Void();
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11583 PyObject *resultobj = 0;
11584 wxGrid *arg1 = (wxGrid *) 0 ;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 PyObject *swig_obj[1] ;
11588
11589 if (!args) SWIG_fail;
11590 swig_obj[0] = args;
11591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11592 if (!SWIG_IsOK(res1)) {
11593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11594 }
11595 arg1 = reinterpret_cast< wxGrid * >(argp1);
11596 {
11597 PyThreadState* __tstate = wxPyBeginAllowThreads();
11598 (arg1)->DisableCellEditControl();
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 resultobj = SWIG_Py_Void();
11603 return resultobj;
11604 fail:
11605 return NULL;
11606 }
11607
11608
11609 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11610 PyObject *resultobj = 0;
11611 wxGrid *arg1 = (wxGrid *) 0 ;
11612 bool result;
11613 void *argp1 = 0 ;
11614 int res1 = 0 ;
11615 PyObject *swig_obj[1] ;
11616
11617 if (!args) SWIG_fail;
11618 swig_obj[0] = args;
11619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11620 if (!SWIG_IsOK(res1)) {
11621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11622 }
11623 arg1 = reinterpret_cast< wxGrid * >(argp1);
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 {
11631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11632 }
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640 PyObject *resultobj = 0;
11641 wxGrid *arg1 = (wxGrid *) 0 ;
11642 bool result;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 PyObject *swig_obj[1] ;
11646
11647 if (!args) SWIG_fail;
11648 swig_obj[0] = args;
11649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11652 }
11653 arg1 = reinterpret_cast< wxGrid * >(argp1);
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11670 PyObject *resultobj = 0;
11671 wxGrid *arg1 = (wxGrid *) 0 ;
11672 bool result;
11673 void *argp1 = 0 ;
11674 int res1 = 0 ;
11675 PyObject *swig_obj[1] ;
11676
11677 if (!args) SWIG_fail;
11678 swig_obj[0] = args;
11679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11680 if (!SWIG_IsOK(res1)) {
11681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11682 }
11683 arg1 = reinterpret_cast< wxGrid * >(argp1);
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11687 wxPyEndAllowThreads(__tstate);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 {
11691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11692 }
11693 return resultobj;
11694 fail:
11695 return NULL;
11696 }
11697
11698
11699 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11700 PyObject *resultobj = 0;
11701 wxGrid *arg1 = (wxGrid *) 0 ;
11702 bool result;
11703 void *argp1 = 0 ;
11704 int res1 = 0 ;
11705 PyObject *swig_obj[1] ;
11706
11707 if (!args) SWIG_fail;
11708 swig_obj[0] = args;
11709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11710 if (!SWIG_IsOK(res1)) {
11711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11712 }
11713 arg1 = reinterpret_cast< wxGrid * >(argp1);
11714 {
11715 PyThreadState* __tstate = wxPyBeginAllowThreads();
11716 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11717 wxPyEndAllowThreads(__tstate);
11718 if (PyErr_Occurred()) SWIG_fail;
11719 }
11720 {
11721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11722 }
11723 return resultobj;
11724 fail:
11725 return NULL;
11726 }
11727
11728
11729 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 PyObject *resultobj = 0;
11731 wxGrid *arg1 = (wxGrid *) 0 ;
11732 void *argp1 = 0 ;
11733 int res1 = 0 ;
11734 PyObject *swig_obj[1] ;
11735
11736 if (!args) SWIG_fail;
11737 swig_obj[0] = args;
11738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11739 if (!SWIG_IsOK(res1)) {
11740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11741 }
11742 arg1 = reinterpret_cast< wxGrid * >(argp1);
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 (arg1)->ShowCellEditControl();
11746 wxPyEndAllowThreads(__tstate);
11747 if (PyErr_Occurred()) SWIG_fail;
11748 }
11749 resultobj = SWIG_Py_Void();
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757 PyObject *resultobj = 0;
11758 wxGrid *arg1 = (wxGrid *) 0 ;
11759 void *argp1 = 0 ;
11760 int res1 = 0 ;
11761 PyObject *swig_obj[1] ;
11762
11763 if (!args) SWIG_fail;
11764 swig_obj[0] = args;
11765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11768 }
11769 arg1 = reinterpret_cast< wxGrid * >(argp1);
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 (arg1)->HideCellEditControl();
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 resultobj = SWIG_Py_Void();
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11784 PyObject *resultobj = 0;
11785 wxGrid *arg1 = (wxGrid *) 0 ;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 PyObject *swig_obj[1] ;
11789
11790 if (!args) SWIG_fail;
11791 swig_obj[0] = args;
11792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11795 }
11796 arg1 = reinterpret_cast< wxGrid * >(argp1);
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 (arg1)->SaveEditControlValue();
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 resultobj = SWIG_Py_Void();
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj = 0;
11812 wxGrid *arg1 = (wxGrid *) 0 ;
11813 int arg2 ;
11814 int arg3 ;
11815 wxGridCellCoords result;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 int val2 ;
11819 int ecode2 = 0 ;
11820 int val3 ;
11821 int ecode3 = 0 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 PyObject * obj2 = 0 ;
11825 char * kwnames[] = {
11826 (char *) "self",(char *) "x",(char *) "y", NULL
11827 };
11828
11829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11833 }
11834 arg1 = reinterpret_cast< wxGrid * >(argp1);
11835 ecode2 = SWIG_AsVal_int(obj1, &val2);
11836 if (!SWIG_IsOK(ecode2)) {
11837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11838 }
11839 arg2 = static_cast< int >(val2);
11840 ecode3 = SWIG_AsVal_int(obj2, &val3);
11841 if (!SWIG_IsOK(ecode3)) {
11842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11843 }
11844 arg3 = static_cast< int >(val3);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = wxGrid_XYToCell(arg1,arg2,arg3);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11852 return resultobj;
11853 fail:
11854 return NULL;
11855 }
11856
11857
11858 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11859 PyObject *resultobj = 0;
11860 wxGrid *arg1 = (wxGrid *) 0 ;
11861 int arg2 ;
11862 int result;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 int val2 ;
11866 int ecode2 = 0 ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 char * kwnames[] = {
11870 (char *) "self",(char *) "y", NULL
11871 };
11872
11873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11877 }
11878 arg1 = reinterpret_cast< wxGrid * >(argp1);
11879 ecode2 = SWIG_AsVal_int(obj1, &val2);
11880 if (!SWIG_IsOK(ecode2)) {
11881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11882 }
11883 arg2 = static_cast< int >(val2);
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (int)(arg1)->YToRow(arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 resultobj = SWIG_From_int(static_cast< int >(result));
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11898 PyObject *resultobj = 0;
11899 wxGrid *arg1 = (wxGrid *) 0 ;
11900 int arg2 ;
11901 bool arg3 = (bool) false ;
11902 int result;
11903 void *argp1 = 0 ;
11904 int res1 = 0 ;
11905 int val2 ;
11906 int ecode2 = 0 ;
11907 bool val3 ;
11908 int ecode3 = 0 ;
11909 PyObject * obj0 = 0 ;
11910 PyObject * obj1 = 0 ;
11911 PyObject * obj2 = 0 ;
11912 char * kwnames[] = {
11913 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11914 };
11915
11916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11920 }
11921 arg1 = reinterpret_cast< wxGrid * >(argp1);
11922 ecode2 = SWIG_AsVal_int(obj1, &val2);
11923 if (!SWIG_IsOK(ecode2)) {
11924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11925 }
11926 arg2 = static_cast< int >(val2);
11927 if (obj2) {
11928 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11929 if (!SWIG_IsOK(ecode3)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11931 }
11932 arg3 = static_cast< bool >(val3);
11933 }
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (int)(arg1)->XToCol(arg2,arg3);
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 resultobj = SWIG_From_int(static_cast< int >(result));
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = 0;
11949 wxGrid *arg1 = (wxGrid *) 0 ;
11950 int arg2 ;
11951 int result;
11952 void *argp1 = 0 ;
11953 int res1 = 0 ;
11954 int val2 ;
11955 int ecode2 = 0 ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 char * kwnames[] = {
11959 (char *) "self",(char *) "y", NULL
11960 };
11961
11962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11964 if (!SWIG_IsOK(res1)) {
11965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11966 }
11967 arg1 = reinterpret_cast< wxGrid * >(argp1);
11968 ecode2 = SWIG_AsVal_int(obj1, &val2);
11969 if (!SWIG_IsOK(ecode2)) {
11970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11971 }
11972 arg2 = static_cast< int >(val2);
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)(arg1)->YToEdgeOfRow(arg2);
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 resultobj = SWIG_From_int(static_cast< int >(result));
11980 return resultobj;
11981 fail:
11982 return NULL;
11983 }
11984
11985
11986 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11987 PyObject *resultobj = 0;
11988 wxGrid *arg1 = (wxGrid *) 0 ;
11989 int arg2 ;
11990 int result;
11991 void *argp1 = 0 ;
11992 int res1 = 0 ;
11993 int val2 ;
11994 int ecode2 = 0 ;
11995 PyObject * obj0 = 0 ;
11996 PyObject * obj1 = 0 ;
11997 char * kwnames[] = {
11998 (char *) "self",(char *) "x", NULL
11999 };
12000
12001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12003 if (!SWIG_IsOK(res1)) {
12004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12005 }
12006 arg1 = reinterpret_cast< wxGrid * >(argp1);
12007 ecode2 = SWIG_AsVal_int(obj1, &val2);
12008 if (!SWIG_IsOK(ecode2)) {
12009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12010 }
12011 arg2 = static_cast< int >(val2);
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (int)(arg1)->XToEdgeOfCol(arg2);
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 resultobj = SWIG_From_int(static_cast< int >(result));
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj = 0;
12027 wxGrid *arg1 = (wxGrid *) 0 ;
12028 int arg2 ;
12029 int arg3 ;
12030 wxRect result;
12031 void *argp1 = 0 ;
12032 int res1 = 0 ;
12033 int val2 ;
12034 int ecode2 = 0 ;
12035 int val3 ;
12036 int ecode3 = 0 ;
12037 PyObject * obj0 = 0 ;
12038 PyObject * obj1 = 0 ;
12039 PyObject * obj2 = 0 ;
12040 char * kwnames[] = {
12041 (char *) "self",(char *) "row",(char *) "col", NULL
12042 };
12043
12044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12046 if (!SWIG_IsOK(res1)) {
12047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12048 }
12049 arg1 = reinterpret_cast< wxGrid * >(argp1);
12050 ecode2 = SWIG_AsVal_int(obj1, &val2);
12051 if (!SWIG_IsOK(ecode2)) {
12052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12053 }
12054 arg2 = static_cast< int >(val2);
12055 ecode3 = SWIG_AsVal_int(obj2, &val3);
12056 if (!SWIG_IsOK(ecode3)) {
12057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12058 }
12059 arg3 = static_cast< int >(val3);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (arg1)->CellToRect(arg2,arg3);
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12067 return resultobj;
12068 fail:
12069 return NULL;
12070 }
12071
12072
12073 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12074 PyObject *resultobj = 0;
12075 wxGrid *arg1 = (wxGrid *) 0 ;
12076 int result;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 PyObject *swig_obj[1] ;
12080
12081 if (!args) SWIG_fail;
12082 swig_obj[0] = args;
12083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12084 if (!SWIG_IsOK(res1)) {
12085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12086 }
12087 arg1 = reinterpret_cast< wxGrid * >(argp1);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 result = (int)(arg1)->GetGridCursorRow();
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_From_int(static_cast< int >(result));
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxGrid *arg1 = (wxGrid *) 0 ;
12104 int result;
12105 void *argp1 = 0 ;
12106 int res1 = 0 ;
12107 PyObject *swig_obj[1] ;
12108
12109 if (!args) SWIG_fail;
12110 swig_obj[0] = args;
12111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12112 if (!SWIG_IsOK(res1)) {
12113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12114 }
12115 arg1 = reinterpret_cast< wxGrid * >(argp1);
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (int)(arg1)->GetGridCursorCol();
12119 wxPyEndAllowThreads(__tstate);
12120 if (PyErr_Occurred()) SWIG_fail;
12121 }
12122 resultobj = SWIG_From_int(static_cast< int >(result));
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj = 0;
12131 wxGrid *arg1 = (wxGrid *) 0 ;
12132 int arg2 ;
12133 int arg3 ;
12134 bool arg4 = (bool) true ;
12135 bool result;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 int val2 ;
12139 int ecode2 = 0 ;
12140 int val3 ;
12141 int ecode3 = 0 ;
12142 bool val4 ;
12143 int ecode4 = 0 ;
12144 PyObject * obj0 = 0 ;
12145 PyObject * obj1 = 0 ;
12146 PyObject * obj2 = 0 ;
12147 PyObject * obj3 = 0 ;
12148 char * kwnames[] = {
12149 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12150 };
12151
12152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12156 }
12157 arg1 = reinterpret_cast< wxGrid * >(argp1);
12158 ecode2 = SWIG_AsVal_int(obj1, &val2);
12159 if (!SWIG_IsOK(ecode2)) {
12160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12161 }
12162 arg2 = static_cast< int >(val2);
12163 ecode3 = SWIG_AsVal_int(obj2, &val3);
12164 if (!SWIG_IsOK(ecode3)) {
12165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12166 }
12167 arg3 = static_cast< int >(val3);
12168 if (obj3) {
12169 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12170 if (!SWIG_IsOK(ecode4)) {
12171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12172 }
12173 arg4 = static_cast< bool >(val4);
12174 }
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj = 0;
12192 wxGrid *arg1 = (wxGrid *) 0 ;
12193 int arg2 ;
12194 int arg3 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 int val2 ;
12198 int ecode2 = 0 ;
12199 int val3 ;
12200 int ecode3 = 0 ;
12201 PyObject * obj0 = 0 ;
12202 PyObject * obj1 = 0 ;
12203 PyObject * obj2 = 0 ;
12204 char * kwnames[] = {
12205 (char *) "self",(char *) "row",(char *) "col", NULL
12206 };
12207
12208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12212 }
12213 arg1 = reinterpret_cast< wxGrid * >(argp1);
12214 ecode2 = SWIG_AsVal_int(obj1, &val2);
12215 if (!SWIG_IsOK(ecode2)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12217 }
12218 arg2 = static_cast< int >(val2);
12219 ecode3 = SWIG_AsVal_int(obj2, &val3);
12220 if (!SWIG_IsOK(ecode3)) {
12221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12222 }
12223 arg3 = static_cast< int >(val3);
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 (arg1)->MakeCellVisible(arg2,arg3);
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 resultobj = SWIG_Py_Void();
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj = 0;
12239 wxGrid *arg1 = (wxGrid *) 0 ;
12240 int arg2 ;
12241 int arg3 ;
12242 void *argp1 = 0 ;
12243 int res1 = 0 ;
12244 int val2 ;
12245 int ecode2 = 0 ;
12246 int val3 ;
12247 int ecode3 = 0 ;
12248 PyObject * obj0 = 0 ;
12249 PyObject * obj1 = 0 ;
12250 PyObject * obj2 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "row",(char *) "col", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12259 }
12260 arg1 = reinterpret_cast< wxGrid * >(argp1);
12261 ecode2 = SWIG_AsVal_int(obj1, &val2);
12262 if (!SWIG_IsOK(ecode2)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12264 }
12265 arg2 = static_cast< int >(val2);
12266 ecode3 = SWIG_AsVal_int(obj2, &val3);
12267 if (!SWIG_IsOK(ecode3)) {
12268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12269 }
12270 arg3 = static_cast< int >(val3);
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 (arg1)->SetGridCursor(arg2,arg3);
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 resultobj = SWIG_Py_Void();
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj = 0;
12286 wxGrid *arg1 = (wxGrid *) 0 ;
12287 bool arg2 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 bool val2 ;
12292 int ecode2 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "expandSelection", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12303 }
12304 arg1 = reinterpret_cast< wxGrid * >(argp1);
12305 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12306 if (!SWIG_IsOK(ecode2)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12308 }
12309 arg2 = static_cast< bool >(val2);
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 result = (bool)(arg1)->MoveCursorUp(arg2);
12313 wxPyEndAllowThreads(__tstate);
12314 if (PyErr_Occurred()) SWIG_fail;
12315 }
12316 {
12317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12318 }
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj = 0;
12327 wxGrid *arg1 = (wxGrid *) 0 ;
12328 bool arg2 ;
12329 bool result;
12330 void *argp1 = 0 ;
12331 int res1 = 0 ;
12332 bool val2 ;
12333 int ecode2 = 0 ;
12334 PyObject * obj0 = 0 ;
12335 PyObject * obj1 = 0 ;
12336 char * kwnames[] = {
12337 (char *) "self",(char *) "expandSelection", NULL
12338 };
12339
12340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12342 if (!SWIG_IsOK(res1)) {
12343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12344 }
12345 arg1 = reinterpret_cast< wxGrid * >(argp1);
12346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12347 if (!SWIG_IsOK(ecode2)) {
12348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12349 }
12350 arg2 = static_cast< bool >(val2);
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (bool)(arg1)->MoveCursorDown(arg2);
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 {
12358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12359 }
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj = 0;
12368 wxGrid *arg1 = (wxGrid *) 0 ;
12369 bool arg2 ;
12370 bool result;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 bool val2 ;
12374 int ecode2 = 0 ;
12375 PyObject * obj0 = 0 ;
12376 PyObject * obj1 = 0 ;
12377 char * kwnames[] = {
12378 (char *) "self",(char *) "expandSelection", NULL
12379 };
12380
12381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12385 }
12386 arg1 = reinterpret_cast< wxGrid * >(argp1);
12387 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12388 if (!SWIG_IsOK(ecode2)) {
12389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12390 }
12391 arg2 = static_cast< bool >(val2);
12392 {
12393 PyThreadState* __tstate = wxPyBeginAllowThreads();
12394 result = (bool)(arg1)->MoveCursorLeft(arg2);
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 {
12399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 wxGrid *arg1 = (wxGrid *) 0 ;
12410 bool arg2 ;
12411 bool result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 bool val2 ;
12415 int ecode2 = 0 ;
12416 PyObject * obj0 = 0 ;
12417 PyObject * obj1 = 0 ;
12418 char * kwnames[] = {
12419 (char *) "self",(char *) "expandSelection", NULL
12420 };
12421
12422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12424 if (!SWIG_IsOK(res1)) {
12425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12426 }
12427 arg1 = reinterpret_cast< wxGrid * >(argp1);
12428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12429 if (!SWIG_IsOK(ecode2)) {
12430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12431 }
12432 arg2 = static_cast< bool >(val2);
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (bool)(arg1)->MoveCursorRight(arg2);
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 {
12440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12441 }
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxGrid *arg1 = (wxGrid *) 0 ;
12451 bool result;
12452 void *argp1 = 0 ;
12453 int res1 = 0 ;
12454 PyObject *swig_obj[1] ;
12455
12456 if (!args) SWIG_fail;
12457 swig_obj[0] = args;
12458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12459 if (!SWIG_IsOK(res1)) {
12460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12461 }
12462 arg1 = reinterpret_cast< wxGrid * >(argp1);
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (bool)(arg1)->MovePageDown();
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12479 PyObject *resultobj = 0;
12480 wxGrid *arg1 = (wxGrid *) 0 ;
12481 bool result;
12482 void *argp1 = 0 ;
12483 int res1 = 0 ;
12484 PyObject *swig_obj[1] ;
12485
12486 if (!args) SWIG_fail;
12487 swig_obj[0] = args;
12488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12489 if (!SWIG_IsOK(res1)) {
12490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12491 }
12492 arg1 = reinterpret_cast< wxGrid * >(argp1);
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 result = (bool)(arg1)->MovePageUp();
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 {
12500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj = 0;
12510 wxGrid *arg1 = (wxGrid *) 0 ;
12511 bool arg2 ;
12512 bool result;
12513 void *argp1 = 0 ;
12514 int res1 = 0 ;
12515 bool val2 ;
12516 int ecode2 = 0 ;
12517 PyObject * obj0 = 0 ;
12518 PyObject * obj1 = 0 ;
12519 char * kwnames[] = {
12520 (char *) "self",(char *) "expandSelection", NULL
12521 };
12522
12523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12525 if (!SWIG_IsOK(res1)) {
12526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12527 }
12528 arg1 = reinterpret_cast< wxGrid * >(argp1);
12529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12530 if (!SWIG_IsOK(ecode2)) {
12531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12532 }
12533 arg2 = static_cast< bool >(val2);
12534 {
12535 PyThreadState* __tstate = wxPyBeginAllowThreads();
12536 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 {
12541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12542 }
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj = 0;
12551 wxGrid *arg1 = (wxGrid *) 0 ;
12552 bool arg2 ;
12553 bool result;
12554 void *argp1 = 0 ;
12555 int res1 = 0 ;
12556 bool val2 ;
12557 int ecode2 = 0 ;
12558 PyObject * obj0 = 0 ;
12559 PyObject * obj1 = 0 ;
12560 char * kwnames[] = {
12561 (char *) "self",(char *) "expandSelection", NULL
12562 };
12563
12564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12566 if (!SWIG_IsOK(res1)) {
12567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12568 }
12569 arg1 = reinterpret_cast< wxGrid * >(argp1);
12570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12571 if (!SWIG_IsOK(ecode2)) {
12572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12573 }
12574 arg2 = static_cast< bool >(val2);
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12578 wxPyEndAllowThreads(__tstate);
12579 if (PyErr_Occurred()) SWIG_fail;
12580 }
12581 {
12582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12583 }
12584 return resultobj;
12585 fail:
12586 return NULL;
12587 }
12588
12589
12590 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj = 0;
12592 wxGrid *arg1 = (wxGrid *) 0 ;
12593 bool arg2 ;
12594 bool result;
12595 void *argp1 = 0 ;
12596 int res1 = 0 ;
12597 bool val2 ;
12598 int ecode2 = 0 ;
12599 PyObject * obj0 = 0 ;
12600 PyObject * obj1 = 0 ;
12601 char * kwnames[] = {
12602 (char *) "self",(char *) "expandSelection", NULL
12603 };
12604
12605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12607 if (!SWIG_IsOK(res1)) {
12608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12609 }
12610 arg1 = reinterpret_cast< wxGrid * >(argp1);
12611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12612 if (!SWIG_IsOK(ecode2)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12614 }
12615 arg2 = static_cast< bool >(val2);
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 wxGrid *arg1 = (wxGrid *) 0 ;
12634 bool arg2 ;
12635 bool result;
12636 void *argp1 = 0 ;
12637 int res1 = 0 ;
12638 bool val2 ;
12639 int ecode2 = 0 ;
12640 PyObject * obj0 = 0 ;
12641 PyObject * obj1 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "self",(char *) "expandSelection", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12648 if (!SWIG_IsOK(res1)) {
12649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12650 }
12651 arg1 = reinterpret_cast< wxGrid * >(argp1);
12652 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12653 if (!SWIG_IsOK(ecode2)) {
12654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12655 }
12656 arg2 = static_cast< bool >(val2);
12657 {
12658 PyThreadState* __tstate = wxPyBeginAllowThreads();
12659 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 {
12664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12665 }
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxGrid *arg1 = (wxGrid *) 0 ;
12675 int result;
12676 void *argp1 = 0 ;
12677 int res1 = 0 ;
12678 PyObject *swig_obj[1] ;
12679
12680 if (!args) SWIG_fail;
12681 swig_obj[0] = args;
12682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12683 if (!SWIG_IsOK(res1)) {
12684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12685 }
12686 arg1 = reinterpret_cast< wxGrid * >(argp1);
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (int)(arg1)->GetDefaultRowLabelSize();
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 resultobj = SWIG_From_int(static_cast< int >(result));
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12701 PyObject *resultobj = 0;
12702 wxGrid *arg1 = (wxGrid *) 0 ;
12703 int result;
12704 void *argp1 = 0 ;
12705 int res1 = 0 ;
12706 PyObject *swig_obj[1] ;
12707
12708 if (!args) SWIG_fail;
12709 swig_obj[0] = args;
12710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12711 if (!SWIG_IsOK(res1)) {
12712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12713 }
12714 arg1 = reinterpret_cast< wxGrid * >(argp1);
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 result = (int)(arg1)->GetRowLabelSize();
12718 wxPyEndAllowThreads(__tstate);
12719 if (PyErr_Occurred()) SWIG_fail;
12720 }
12721 resultobj = SWIG_From_int(static_cast< int >(result));
12722 return resultobj;
12723 fail:
12724 return NULL;
12725 }
12726
12727
12728 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12729 PyObject *resultobj = 0;
12730 wxGrid *arg1 = (wxGrid *) 0 ;
12731 int result;
12732 void *argp1 = 0 ;
12733 int res1 = 0 ;
12734 PyObject *swig_obj[1] ;
12735
12736 if (!args) SWIG_fail;
12737 swig_obj[0] = args;
12738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12739 if (!SWIG_IsOK(res1)) {
12740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12741 }
12742 arg1 = reinterpret_cast< wxGrid * >(argp1);
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 result = (int)(arg1)->GetDefaultColLabelSize();
12746 wxPyEndAllowThreads(__tstate);
12747 if (PyErr_Occurred()) SWIG_fail;
12748 }
12749 resultobj = SWIG_From_int(static_cast< int >(result));
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 PyObject *resultobj = 0;
12758 wxGrid *arg1 = (wxGrid *) 0 ;
12759 int result;
12760 void *argp1 = 0 ;
12761 int res1 = 0 ;
12762 PyObject *swig_obj[1] ;
12763
12764 if (!args) SWIG_fail;
12765 swig_obj[0] = args;
12766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12767 if (!SWIG_IsOK(res1)) {
12768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12769 }
12770 arg1 = reinterpret_cast< wxGrid * >(argp1);
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 result = (int)(arg1)->GetColLabelSize();
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 resultobj = SWIG_From_int(static_cast< int >(result));
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12785 PyObject *resultobj = 0;
12786 wxGrid *arg1 = (wxGrid *) 0 ;
12787 wxColour result;
12788 void *argp1 = 0 ;
12789 int res1 = 0 ;
12790 PyObject *swig_obj[1] ;
12791
12792 if (!args) SWIG_fail;
12793 swig_obj[0] = args;
12794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12795 if (!SWIG_IsOK(res1)) {
12796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12797 }
12798 arg1 = reinterpret_cast< wxGrid * >(argp1);
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (arg1)->GetLabelBackgroundColour();
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12813 PyObject *resultobj = 0;
12814 wxGrid *arg1 = (wxGrid *) 0 ;
12815 wxColour result;
12816 void *argp1 = 0 ;
12817 int res1 = 0 ;
12818 PyObject *swig_obj[1] ;
12819
12820 if (!args) SWIG_fail;
12821 swig_obj[0] = args;
12822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12823 if (!SWIG_IsOK(res1)) {
12824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12825 }
12826 arg1 = reinterpret_cast< wxGrid * >(argp1);
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (arg1)->GetLabelTextColour();
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12841 PyObject *resultobj = 0;
12842 wxGrid *arg1 = (wxGrid *) 0 ;
12843 wxFont result;
12844 void *argp1 = 0 ;
12845 int res1 = 0 ;
12846 PyObject *swig_obj[1] ;
12847
12848 if (!args) SWIG_fail;
12849 swig_obj[0] = args;
12850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12851 if (!SWIG_IsOK(res1)) {
12852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12853 }
12854 arg1 = reinterpret_cast< wxGrid * >(argp1);
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 result = (arg1)->GetLabelFont();
12858 wxPyEndAllowThreads(__tstate);
12859 if (PyErr_Occurred()) SWIG_fail;
12860 }
12861 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869 PyObject *resultobj = 0;
12870 wxGrid *arg1 = (wxGrid *) 0 ;
12871 int *arg2 = (int *) 0 ;
12872 int *arg3 = (int *) 0 ;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 int temp2 ;
12876 int res2 = SWIG_TMPOBJ ;
12877 int temp3 ;
12878 int res3 = SWIG_TMPOBJ ;
12879 PyObject *swig_obj[1] ;
12880
12881 arg2 = &temp2;
12882 arg3 = &temp3;
12883 if (!args) SWIG_fail;
12884 swig_obj[0] = args;
12885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12886 if (!SWIG_IsOK(res1)) {
12887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12888 }
12889 arg1 = reinterpret_cast< wxGrid * >(argp1);
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 (arg1)->GetRowLabelAlignment(arg2,arg3);
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 resultobj = SWIG_Py_Void();
12897 if (SWIG_IsTmpObj(res2)) {
12898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12899 } else {
12900 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12902 }
12903 if (SWIG_IsTmpObj(res3)) {
12904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12905 } else {
12906 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12908 }
12909 return resultobj;
12910 fail:
12911 return NULL;
12912 }
12913
12914
12915 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 PyObject *resultobj = 0;
12917 wxGrid *arg1 = (wxGrid *) 0 ;
12918 int *arg2 = (int *) 0 ;
12919 int *arg3 = (int *) 0 ;
12920 void *argp1 = 0 ;
12921 int res1 = 0 ;
12922 int temp2 ;
12923 int res2 = SWIG_TMPOBJ ;
12924 int temp3 ;
12925 int res3 = SWIG_TMPOBJ ;
12926 PyObject *swig_obj[1] ;
12927
12928 arg2 = &temp2;
12929 arg3 = &temp3;
12930 if (!args) SWIG_fail;
12931 swig_obj[0] = args;
12932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12933 if (!SWIG_IsOK(res1)) {
12934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12935 }
12936 arg1 = reinterpret_cast< wxGrid * >(argp1);
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 (arg1)->GetColLabelAlignment(arg2,arg3);
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 resultobj = SWIG_Py_Void();
12944 if (SWIG_IsTmpObj(res2)) {
12945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12946 } else {
12947 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12949 }
12950 if (SWIG_IsTmpObj(res3)) {
12951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12952 } else {
12953 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12955 }
12956 return resultobj;
12957 fail:
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxGrid *arg1 = (wxGrid *) 0 ;
12965 int result;
12966 void *argp1 = 0 ;
12967 int res1 = 0 ;
12968 PyObject *swig_obj[1] ;
12969
12970 if (!args) SWIG_fail;
12971 swig_obj[0] = args;
12972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12973 if (!SWIG_IsOK(res1)) {
12974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12975 }
12976 arg1 = reinterpret_cast< wxGrid * >(argp1);
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (int)(arg1)->GetColLabelTextOrientation();
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_From_int(static_cast< int >(result));
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj = 0;
12992 wxGrid *arg1 = (wxGrid *) 0 ;
12993 int arg2 ;
12994 wxString result;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 int val2 ;
12998 int ecode2 = 0 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 char * kwnames[] = {
13002 (char *) "self",(char *) "row", NULL
13003 };
13004
13005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13007 if (!SWIG_IsOK(res1)) {
13008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13009 }
13010 arg1 = reinterpret_cast< wxGrid * >(argp1);
13011 ecode2 = SWIG_AsVal_int(obj1, &val2);
13012 if (!SWIG_IsOK(ecode2)) {
13013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13014 }
13015 arg2 = static_cast< int >(val2);
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (arg1)->GetRowLabelValue(arg2);
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 {
13023 #if wxUSE_UNICODE
13024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13025 #else
13026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13027 #endif
13028 }
13029 return resultobj;
13030 fail:
13031 return NULL;
13032 }
13033
13034
13035 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13036 PyObject *resultobj = 0;
13037 wxGrid *arg1 = (wxGrid *) 0 ;
13038 int arg2 ;
13039 wxString result;
13040 void *argp1 = 0 ;
13041 int res1 = 0 ;
13042 int val2 ;
13043 int ecode2 = 0 ;
13044 PyObject * obj0 = 0 ;
13045 PyObject * obj1 = 0 ;
13046 char * kwnames[] = {
13047 (char *) "self",(char *) "col", NULL
13048 };
13049
13050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13052 if (!SWIG_IsOK(res1)) {
13053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13054 }
13055 arg1 = reinterpret_cast< wxGrid * >(argp1);
13056 ecode2 = SWIG_AsVal_int(obj1, &val2);
13057 if (!SWIG_IsOK(ecode2)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13059 }
13060 arg2 = static_cast< int >(val2);
13061 {
13062 PyThreadState* __tstate = wxPyBeginAllowThreads();
13063 result = (arg1)->GetColLabelValue(arg2);
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 {
13068 #if wxUSE_UNICODE
13069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13070 #else
13071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13072 #endif
13073 }
13074 return resultobj;
13075 fail:
13076 return NULL;
13077 }
13078
13079
13080 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13081 PyObject *resultobj = 0;
13082 wxGrid *arg1 = (wxGrid *) 0 ;
13083 wxColour result;
13084 void *argp1 = 0 ;
13085 int res1 = 0 ;
13086 PyObject *swig_obj[1] ;
13087
13088 if (!args) SWIG_fail;
13089 swig_obj[0] = args;
13090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13091 if (!SWIG_IsOK(res1)) {
13092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13093 }
13094 arg1 = reinterpret_cast< wxGrid * >(argp1);
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 result = (arg1)->GetGridLineColour();
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109 PyObject *resultobj = 0;
13110 wxGrid *arg1 = (wxGrid *) 0 ;
13111 wxColour result;
13112 void *argp1 = 0 ;
13113 int res1 = 0 ;
13114 PyObject *swig_obj[1] ;
13115
13116 if (!args) SWIG_fail;
13117 swig_obj[0] = args;
13118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13119 if (!SWIG_IsOK(res1)) {
13120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13121 }
13122 arg1 = reinterpret_cast< wxGrid * >(argp1);
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (arg1)->GetCellHighlightColour();
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13137 PyObject *resultobj = 0;
13138 wxGrid *arg1 = (wxGrid *) 0 ;
13139 int result;
13140 void *argp1 = 0 ;
13141 int res1 = 0 ;
13142 PyObject *swig_obj[1] ;
13143
13144 if (!args) SWIG_fail;
13145 swig_obj[0] = args;
13146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13147 if (!SWIG_IsOK(res1)) {
13148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13149 }
13150 arg1 = reinterpret_cast< wxGrid * >(argp1);
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (int)(arg1)->GetCellHighlightPenWidth();
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 resultobj = SWIG_From_int(static_cast< int >(result));
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13165 PyObject *resultobj = 0;
13166 wxGrid *arg1 = (wxGrid *) 0 ;
13167 int result;
13168 void *argp1 = 0 ;
13169 int res1 = 0 ;
13170 PyObject *swig_obj[1] ;
13171
13172 if (!args) SWIG_fail;
13173 swig_obj[0] = args;
13174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13175 if (!SWIG_IsOK(res1)) {
13176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13177 }
13178 arg1 = reinterpret_cast< wxGrid * >(argp1);
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (int)(arg1)->GetCellHighlightROPenWidth();
13182 wxPyEndAllowThreads(__tstate);
13183 if (PyErr_Occurred()) SWIG_fail;
13184 }
13185 resultobj = SWIG_From_int(static_cast< int >(result));
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj = 0;
13194 wxGrid *arg1 = (wxGrid *) 0 ;
13195 int arg2 ;
13196 void *argp1 = 0 ;
13197 int res1 = 0 ;
13198 int val2 ;
13199 int ecode2 = 0 ;
13200 PyObject * obj0 = 0 ;
13201 PyObject * obj1 = 0 ;
13202 char * kwnames[] = {
13203 (char *) "self",(char *) "width", NULL
13204 };
13205
13206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13208 if (!SWIG_IsOK(res1)) {
13209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13210 }
13211 arg1 = reinterpret_cast< wxGrid * >(argp1);
13212 ecode2 = SWIG_AsVal_int(obj1, &val2);
13213 if (!SWIG_IsOK(ecode2)) {
13214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13215 }
13216 arg2 = static_cast< int >(val2);
13217 {
13218 PyThreadState* __tstate = wxPyBeginAllowThreads();
13219 (arg1)->SetRowLabelSize(arg2);
13220 wxPyEndAllowThreads(__tstate);
13221 if (PyErr_Occurred()) SWIG_fail;
13222 }
13223 resultobj = SWIG_Py_Void();
13224 return resultobj;
13225 fail:
13226 return NULL;
13227 }
13228
13229
13230 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13231 PyObject *resultobj = 0;
13232 wxGrid *arg1 = (wxGrid *) 0 ;
13233 int arg2 ;
13234 void *argp1 = 0 ;
13235 int res1 = 0 ;
13236 int val2 ;
13237 int ecode2 = 0 ;
13238 PyObject * obj0 = 0 ;
13239 PyObject * obj1 = 0 ;
13240 char * kwnames[] = {
13241 (char *) "self",(char *) "height", NULL
13242 };
13243
13244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13246 if (!SWIG_IsOK(res1)) {
13247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13248 }
13249 arg1 = reinterpret_cast< wxGrid * >(argp1);
13250 ecode2 = SWIG_AsVal_int(obj1, &val2);
13251 if (!SWIG_IsOK(ecode2)) {
13252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13253 }
13254 arg2 = static_cast< int >(val2);
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 (arg1)->SetColLabelSize(arg2);
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_Py_Void();
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj = 0;
13270 wxGrid *arg1 = (wxGrid *) 0 ;
13271 wxColour *arg2 = 0 ;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 wxColour temp2 ;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 char * kwnames[] = {
13278 (char *) "self",(char *)"arg2", NULL
13279 };
13280
13281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13283 if (!SWIG_IsOK(res1)) {
13284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13285 }
13286 arg1 = reinterpret_cast< wxGrid * >(argp1);
13287 {
13288 arg2 = &temp2;
13289 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13290 }
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxGrid *arg1 = (wxGrid *) 0 ;
13307 wxColour *arg2 = 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 wxColour temp2 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 char * kwnames[] = {
13314 (char *) "self",(char *)"arg2", NULL
13315 };
13316
13317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13319 if (!SWIG_IsOK(res1)) {
13320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13321 }
13322 arg1 = reinterpret_cast< wxGrid * >(argp1);
13323 {
13324 arg2 = &temp2;
13325 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13326 }
13327 {
13328 PyThreadState* __tstate = wxPyBeginAllowThreads();
13329 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13330 wxPyEndAllowThreads(__tstate);
13331 if (PyErr_Occurred()) SWIG_fail;
13332 }
13333 resultobj = SWIG_Py_Void();
13334 return resultobj;
13335 fail:
13336 return NULL;
13337 }
13338
13339
13340 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13341 PyObject *resultobj = 0;
13342 wxGrid *arg1 = (wxGrid *) 0 ;
13343 wxFont *arg2 = 0 ;
13344 void *argp1 = 0 ;
13345 int res1 = 0 ;
13346 void *argp2 = 0 ;
13347 int res2 = 0 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 char * kwnames[] = {
13351 (char *) "self",(char *)"arg2", NULL
13352 };
13353
13354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13356 if (!SWIG_IsOK(res1)) {
13357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13358 }
13359 arg1 = reinterpret_cast< wxGrid * >(argp1);
13360 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13361 if (!SWIG_IsOK(res2)) {
13362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13363 }
13364 if (!argp2) {
13365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13366 }
13367 arg2 = reinterpret_cast< wxFont * >(argp2);
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 (arg1)->SetLabelFont((wxFont const &)*arg2);
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 resultobj = SWIG_Py_Void();
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj = 0;
13383 wxGrid *arg1 = (wxGrid *) 0 ;
13384 int arg2 ;
13385 int arg3 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 int val2 ;
13389 int ecode2 = 0 ;
13390 int val3 ;
13391 int ecode3 = 0 ;
13392 PyObject * obj0 = 0 ;
13393 PyObject * obj1 = 0 ;
13394 PyObject * obj2 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13403 }
13404 arg1 = reinterpret_cast< wxGrid * >(argp1);
13405 ecode2 = SWIG_AsVal_int(obj1, &val2);
13406 if (!SWIG_IsOK(ecode2)) {
13407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13408 }
13409 arg2 = static_cast< int >(val2);
13410 ecode3 = SWIG_AsVal_int(obj2, &val3);
13411 if (!SWIG_IsOK(ecode3)) {
13412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13413 }
13414 arg3 = static_cast< int >(val3);
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 (arg1)->SetRowLabelAlignment(arg2,arg3);
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 resultobj = SWIG_Py_Void();
13422 return resultobj;
13423 fail:
13424 return NULL;
13425 }
13426
13427
13428 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13429 PyObject *resultobj = 0;
13430 wxGrid *arg1 = (wxGrid *) 0 ;
13431 int arg2 ;
13432 int arg3 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 int val2 ;
13436 int ecode2 = 0 ;
13437 int val3 ;
13438 int ecode3 = 0 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 PyObject * obj2 = 0 ;
13442 char * kwnames[] = {
13443 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13444 };
13445
13446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13450 }
13451 arg1 = reinterpret_cast< wxGrid * >(argp1);
13452 ecode2 = SWIG_AsVal_int(obj1, &val2);
13453 if (!SWIG_IsOK(ecode2)) {
13454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13455 }
13456 arg2 = static_cast< int >(val2);
13457 ecode3 = SWIG_AsVal_int(obj2, &val3);
13458 if (!SWIG_IsOK(ecode3)) {
13459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13460 }
13461 arg3 = static_cast< int >(val3);
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 (arg1)->SetColLabelAlignment(arg2,arg3);
13465 wxPyEndAllowThreads(__tstate);
13466 if (PyErr_Occurred()) SWIG_fail;
13467 }
13468 resultobj = SWIG_Py_Void();
13469 return resultobj;
13470 fail:
13471 return NULL;
13472 }
13473
13474
13475 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj = 0;
13477 wxGrid *arg1 = (wxGrid *) 0 ;
13478 int arg2 ;
13479 void *argp1 = 0 ;
13480 int res1 = 0 ;
13481 int val2 ;
13482 int ecode2 = 0 ;
13483 PyObject * obj0 = 0 ;
13484 PyObject * obj1 = 0 ;
13485 char * kwnames[] = {
13486 (char *) "self",(char *) "textOrientation", NULL
13487 };
13488
13489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13491 if (!SWIG_IsOK(res1)) {
13492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13493 }
13494 arg1 = reinterpret_cast< wxGrid * >(argp1);
13495 ecode2 = SWIG_AsVal_int(obj1, &val2);
13496 if (!SWIG_IsOK(ecode2)) {
13497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13498 }
13499 arg2 = static_cast< int >(val2);
13500 {
13501 PyThreadState* __tstate = wxPyBeginAllowThreads();
13502 (arg1)->SetColLabelTextOrientation(arg2);
13503 wxPyEndAllowThreads(__tstate);
13504 if (PyErr_Occurred()) SWIG_fail;
13505 }
13506 resultobj = SWIG_Py_Void();
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj = 0;
13515 wxGrid *arg1 = (wxGrid *) 0 ;
13516 int arg2 ;
13517 wxString *arg3 = 0 ;
13518 void *argp1 = 0 ;
13519 int res1 = 0 ;
13520 int val2 ;
13521 int ecode2 = 0 ;
13522 bool temp3 = false ;
13523 PyObject * obj0 = 0 ;
13524 PyObject * obj1 = 0 ;
13525 PyObject * obj2 = 0 ;
13526 char * kwnames[] = {
13527 (char *) "self",(char *) "row",(char *)"arg3", NULL
13528 };
13529
13530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13532 if (!SWIG_IsOK(res1)) {
13533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13534 }
13535 arg1 = reinterpret_cast< wxGrid * >(argp1);
13536 ecode2 = SWIG_AsVal_int(obj1, &val2);
13537 if (!SWIG_IsOK(ecode2)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13539 }
13540 arg2 = static_cast< int >(val2);
13541 {
13542 arg3 = wxString_in_helper(obj2);
13543 if (arg3 == NULL) SWIG_fail;
13544 temp3 = true;
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_Py_Void();
13553 {
13554 if (temp3)
13555 delete arg3;
13556 }
13557 return resultobj;
13558 fail:
13559 {
13560 if (temp3)
13561 delete arg3;
13562 }
13563 return NULL;
13564 }
13565
13566
13567 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13568 PyObject *resultobj = 0;
13569 wxGrid *arg1 = (wxGrid *) 0 ;
13570 int arg2 ;
13571 wxString *arg3 = 0 ;
13572 void *argp1 = 0 ;
13573 int res1 = 0 ;
13574 int val2 ;
13575 int ecode2 = 0 ;
13576 bool temp3 = false ;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 PyObject * obj2 = 0 ;
13580 char * kwnames[] = {
13581 (char *) "self",(char *) "col",(char *)"arg3", NULL
13582 };
13583
13584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13586 if (!SWIG_IsOK(res1)) {
13587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13588 }
13589 arg1 = reinterpret_cast< wxGrid * >(argp1);
13590 ecode2 = SWIG_AsVal_int(obj1, &val2);
13591 if (!SWIG_IsOK(ecode2)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13593 }
13594 arg2 = static_cast< int >(val2);
13595 {
13596 arg3 = wxString_in_helper(obj2);
13597 if (arg3 == NULL) SWIG_fail;
13598 temp3 = true;
13599 }
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_Py_Void();
13607 {
13608 if (temp3)
13609 delete arg3;
13610 }
13611 return resultobj;
13612 fail:
13613 {
13614 if (temp3)
13615 delete arg3;
13616 }
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxGrid *arg1 = (wxGrid *) 0 ;
13624 wxColour *arg2 = 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 wxColour temp2 ;
13628 PyObject * obj0 = 0 ;
13629 PyObject * obj1 = 0 ;
13630 char * kwnames[] = {
13631 (char *) "self",(char *)"arg2", NULL
13632 };
13633
13634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13636 if (!SWIG_IsOK(res1)) {
13637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13638 }
13639 arg1 = reinterpret_cast< wxGrid * >(argp1);
13640 {
13641 arg2 = &temp2;
13642 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13643 }
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 resultobj = SWIG_Py_Void();
13651 return resultobj;
13652 fail:
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj = 0;
13659 wxGrid *arg1 = (wxGrid *) 0 ;
13660 wxColour *arg2 = 0 ;
13661 void *argp1 = 0 ;
13662 int res1 = 0 ;
13663 wxColour temp2 ;
13664 PyObject * obj0 = 0 ;
13665 PyObject * obj1 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "self",(char *)"arg2", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13672 if (!SWIG_IsOK(res1)) {
13673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13674 }
13675 arg1 = reinterpret_cast< wxGrid * >(argp1);
13676 {
13677 arg2 = &temp2;
13678 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13679 }
13680 {
13681 PyThreadState* __tstate = wxPyBeginAllowThreads();
13682 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13683 wxPyEndAllowThreads(__tstate);
13684 if (PyErr_Occurred()) SWIG_fail;
13685 }
13686 resultobj = SWIG_Py_Void();
13687 return resultobj;
13688 fail:
13689 return NULL;
13690 }
13691
13692
13693 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13694 PyObject *resultobj = 0;
13695 wxGrid *arg1 = (wxGrid *) 0 ;
13696 int arg2 ;
13697 void *argp1 = 0 ;
13698 int res1 = 0 ;
13699 int val2 ;
13700 int ecode2 = 0 ;
13701 PyObject * obj0 = 0 ;
13702 PyObject * obj1 = 0 ;
13703 char * kwnames[] = {
13704 (char *) "self",(char *) "width", NULL
13705 };
13706
13707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13709 if (!SWIG_IsOK(res1)) {
13710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13711 }
13712 arg1 = reinterpret_cast< wxGrid * >(argp1);
13713 ecode2 = SWIG_AsVal_int(obj1, &val2);
13714 if (!SWIG_IsOK(ecode2)) {
13715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13716 }
13717 arg2 = static_cast< int >(val2);
13718 {
13719 PyThreadState* __tstate = wxPyBeginAllowThreads();
13720 (arg1)->SetCellHighlightPenWidth(arg2);
13721 wxPyEndAllowThreads(__tstate);
13722 if (PyErr_Occurred()) SWIG_fail;
13723 }
13724 resultobj = SWIG_Py_Void();
13725 return resultobj;
13726 fail:
13727 return NULL;
13728 }
13729
13730
13731 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13732 PyObject *resultobj = 0;
13733 wxGrid *arg1 = (wxGrid *) 0 ;
13734 int arg2 ;
13735 void *argp1 = 0 ;
13736 int res1 = 0 ;
13737 int val2 ;
13738 int ecode2 = 0 ;
13739 PyObject * obj0 = 0 ;
13740 PyObject * obj1 = 0 ;
13741 char * kwnames[] = {
13742 (char *) "self",(char *) "width", NULL
13743 };
13744
13745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13747 if (!SWIG_IsOK(res1)) {
13748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13749 }
13750 arg1 = reinterpret_cast< wxGrid * >(argp1);
13751 ecode2 = SWIG_AsVal_int(obj1, &val2);
13752 if (!SWIG_IsOK(ecode2)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13754 }
13755 arg2 = static_cast< int >(val2);
13756 {
13757 PyThreadState* __tstate = wxPyBeginAllowThreads();
13758 (arg1)->SetCellHighlightROPenWidth(arg2);
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 resultobj = SWIG_Py_Void();
13763 return resultobj;
13764 fail:
13765 return NULL;
13766 }
13767
13768
13769 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj = 0;
13771 wxGrid *arg1 = (wxGrid *) 0 ;
13772 bool arg2 = (bool) true ;
13773 void *argp1 = 0 ;
13774 int res1 = 0 ;
13775 bool val2 ;
13776 int ecode2 = 0 ;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "self",(char *) "enable", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13787 }
13788 arg1 = reinterpret_cast< wxGrid * >(argp1);
13789 if (obj1) {
13790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13791 if (!SWIG_IsOK(ecode2)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13793 }
13794 arg2 = static_cast< bool >(val2);
13795 }
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 (arg1)->EnableDragRowSize(arg2);
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_Py_Void();
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13810 PyObject *resultobj = 0;
13811 wxGrid *arg1 = (wxGrid *) 0 ;
13812 void *argp1 = 0 ;
13813 int res1 = 0 ;
13814 PyObject *swig_obj[1] ;
13815
13816 if (!args) SWIG_fail;
13817 swig_obj[0] = args;
13818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13819 if (!SWIG_IsOK(res1)) {
13820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13821 }
13822 arg1 = reinterpret_cast< wxGrid * >(argp1);
13823 {
13824 PyThreadState* __tstate = wxPyBeginAllowThreads();
13825 (arg1)->DisableDragRowSize();
13826 wxPyEndAllowThreads(__tstate);
13827 if (PyErr_Occurred()) SWIG_fail;
13828 }
13829 resultobj = SWIG_Py_Void();
13830 return resultobj;
13831 fail:
13832 return NULL;
13833 }
13834
13835
13836 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13837 PyObject *resultobj = 0;
13838 wxGrid *arg1 = (wxGrid *) 0 ;
13839 bool result;
13840 void *argp1 = 0 ;
13841 int res1 = 0 ;
13842 PyObject *swig_obj[1] ;
13843
13844 if (!args) SWIG_fail;
13845 swig_obj[0] = args;
13846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13847 if (!SWIG_IsOK(res1)) {
13848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13849 }
13850 arg1 = reinterpret_cast< wxGrid * >(argp1);
13851 {
13852 PyThreadState* __tstate = wxPyBeginAllowThreads();
13853 result = (bool)(arg1)->CanDragRowSize();
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 {
13858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13859 }
13860 return resultobj;
13861 fail:
13862 return NULL;
13863 }
13864
13865
13866 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13867 PyObject *resultobj = 0;
13868 wxGrid *arg1 = (wxGrid *) 0 ;
13869 bool arg2 = (bool) true ;
13870 void *argp1 = 0 ;
13871 int res1 = 0 ;
13872 bool val2 ;
13873 int ecode2 = 0 ;
13874 PyObject * obj0 = 0 ;
13875 PyObject * obj1 = 0 ;
13876 char * kwnames[] = {
13877 (char *) "self",(char *) "enable", NULL
13878 };
13879
13880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13882 if (!SWIG_IsOK(res1)) {
13883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13884 }
13885 arg1 = reinterpret_cast< wxGrid * >(argp1);
13886 if (obj1) {
13887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13888 if (!SWIG_IsOK(ecode2)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13890 }
13891 arg2 = static_cast< bool >(val2);
13892 }
13893 {
13894 PyThreadState* __tstate = wxPyBeginAllowThreads();
13895 (arg1)->EnableDragColSize(arg2);
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 resultobj = SWIG_Py_Void();
13900 return resultobj;
13901 fail:
13902 return NULL;
13903 }
13904
13905
13906 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13907 PyObject *resultobj = 0;
13908 wxGrid *arg1 = (wxGrid *) 0 ;
13909 void *argp1 = 0 ;
13910 int res1 = 0 ;
13911 PyObject *swig_obj[1] ;
13912
13913 if (!args) SWIG_fail;
13914 swig_obj[0] = args;
13915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13916 if (!SWIG_IsOK(res1)) {
13917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13918 }
13919 arg1 = reinterpret_cast< wxGrid * >(argp1);
13920 {
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 (arg1)->DisableDragColSize();
13923 wxPyEndAllowThreads(__tstate);
13924 if (PyErr_Occurred()) SWIG_fail;
13925 }
13926 resultobj = SWIG_Py_Void();
13927 return resultobj;
13928 fail:
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13934 PyObject *resultobj = 0;
13935 wxGrid *arg1 = (wxGrid *) 0 ;
13936 bool result;
13937 void *argp1 = 0 ;
13938 int res1 = 0 ;
13939 PyObject *swig_obj[1] ;
13940
13941 if (!args) SWIG_fail;
13942 swig_obj[0] = args;
13943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13944 if (!SWIG_IsOK(res1)) {
13945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13946 }
13947 arg1 = reinterpret_cast< wxGrid * >(argp1);
13948 {
13949 PyThreadState* __tstate = wxPyBeginAllowThreads();
13950 result = (bool)(arg1)->CanDragColSize();
13951 wxPyEndAllowThreads(__tstate);
13952 if (PyErr_Occurred()) SWIG_fail;
13953 }
13954 {
13955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13956 }
13957 return resultobj;
13958 fail:
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13964 PyObject *resultobj = 0;
13965 wxGrid *arg1 = (wxGrid *) 0 ;
13966 bool arg2 = (bool) true ;
13967 void *argp1 = 0 ;
13968 int res1 = 0 ;
13969 bool val2 ;
13970 int ecode2 = 0 ;
13971 PyObject * obj0 = 0 ;
13972 PyObject * obj1 = 0 ;
13973 char * kwnames[] = {
13974 (char *) "self",(char *) "enable", NULL
13975 };
13976
13977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
13978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13979 if (!SWIG_IsOK(res1)) {
13980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
13981 }
13982 arg1 = reinterpret_cast< wxGrid * >(argp1);
13983 if (obj1) {
13984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13985 if (!SWIG_IsOK(ecode2)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
13987 }
13988 arg2 = static_cast< bool >(val2);
13989 }
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 (arg1)->EnableDragColMove(arg2);
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 resultobj = SWIG_Py_Void();
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14004 PyObject *resultobj = 0;
14005 wxGrid *arg1 = (wxGrid *) 0 ;
14006 void *argp1 = 0 ;
14007 int res1 = 0 ;
14008 PyObject *swig_obj[1] ;
14009
14010 if (!args) SWIG_fail;
14011 swig_obj[0] = args;
14012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14013 if (!SWIG_IsOK(res1)) {
14014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14015 }
14016 arg1 = reinterpret_cast< wxGrid * >(argp1);
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 (arg1)->DisableDragColMove();
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 resultobj = SWIG_Py_Void();
14024 return resultobj;
14025 fail:
14026 return NULL;
14027 }
14028
14029
14030 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14031 PyObject *resultobj = 0;
14032 wxGrid *arg1 = (wxGrid *) 0 ;
14033 bool result;
14034 void *argp1 = 0 ;
14035 int res1 = 0 ;
14036 PyObject *swig_obj[1] ;
14037
14038 if (!args) SWIG_fail;
14039 swig_obj[0] = args;
14040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14041 if (!SWIG_IsOK(res1)) {
14042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14043 }
14044 arg1 = reinterpret_cast< wxGrid * >(argp1);
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 result = (bool)(arg1)->CanDragColMove();
14048 wxPyEndAllowThreads(__tstate);
14049 if (PyErr_Occurred()) SWIG_fail;
14050 }
14051 {
14052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14053 }
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14061 PyObject *resultobj = 0;
14062 wxGrid *arg1 = (wxGrid *) 0 ;
14063 bool arg2 = (bool) true ;
14064 void *argp1 = 0 ;
14065 int res1 = 0 ;
14066 bool val2 ;
14067 int ecode2 = 0 ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 char * kwnames[] = {
14071 (char *) "self",(char *) "enable", NULL
14072 };
14073
14074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14076 if (!SWIG_IsOK(res1)) {
14077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14078 }
14079 arg1 = reinterpret_cast< wxGrid * >(argp1);
14080 if (obj1) {
14081 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14082 if (!SWIG_IsOK(ecode2)) {
14083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14084 }
14085 arg2 = static_cast< bool >(val2);
14086 }
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 (arg1)->EnableDragGridSize(arg2);
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_Py_Void();
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14101 PyObject *resultobj = 0;
14102 wxGrid *arg1 = (wxGrid *) 0 ;
14103 void *argp1 = 0 ;
14104 int res1 = 0 ;
14105 PyObject *swig_obj[1] ;
14106
14107 if (!args) SWIG_fail;
14108 swig_obj[0] = args;
14109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14112 }
14113 arg1 = reinterpret_cast< wxGrid * >(argp1);
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 (arg1)->DisableDragGridSize();
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 resultobj = SWIG_Py_Void();
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14128 PyObject *resultobj = 0;
14129 wxGrid *arg1 = (wxGrid *) 0 ;
14130 bool result;
14131 void *argp1 = 0 ;
14132 int res1 = 0 ;
14133 PyObject *swig_obj[1] ;
14134
14135 if (!args) SWIG_fail;
14136 swig_obj[0] = args;
14137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14138 if (!SWIG_IsOK(res1)) {
14139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14140 }
14141 arg1 = reinterpret_cast< wxGrid * >(argp1);
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 result = (bool)(arg1)->CanDragGridSize();
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 {
14149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14150 }
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxGrid *arg1 = (wxGrid *) 0 ;
14160 bool arg2 = (bool) true ;
14161 void *argp1 = 0 ;
14162 int res1 = 0 ;
14163 bool val2 ;
14164 int ecode2 = 0 ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 char * kwnames[] = {
14168 (char *) "self",(char *) "enable", NULL
14169 };
14170
14171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14173 if (!SWIG_IsOK(res1)) {
14174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14175 }
14176 arg1 = reinterpret_cast< wxGrid * >(argp1);
14177 if (obj1) {
14178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14179 if (!SWIG_IsOK(ecode2)) {
14180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14181 }
14182 arg2 = static_cast< bool >(val2);
14183 }
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 (arg1)->EnableDragCell(arg2);
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 resultobj = SWIG_Py_Void();
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *resultobj = 0;
14199 wxGrid *arg1 = (wxGrid *) 0 ;
14200 void *argp1 = 0 ;
14201 int res1 = 0 ;
14202 PyObject *swig_obj[1] ;
14203
14204 if (!args) SWIG_fail;
14205 swig_obj[0] = args;
14206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14207 if (!SWIG_IsOK(res1)) {
14208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14209 }
14210 arg1 = reinterpret_cast< wxGrid * >(argp1);
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 (arg1)->DisableDragCell();
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 resultobj = SWIG_Py_Void();
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14225 PyObject *resultobj = 0;
14226 wxGrid *arg1 = (wxGrid *) 0 ;
14227 bool result;
14228 void *argp1 = 0 ;
14229 int res1 = 0 ;
14230 PyObject *swig_obj[1] ;
14231
14232 if (!args) SWIG_fail;
14233 swig_obj[0] = args;
14234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14235 if (!SWIG_IsOK(res1)) {
14236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14237 }
14238 arg1 = reinterpret_cast< wxGrid * >(argp1);
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 result = (bool)(arg1)->CanDragCell();
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 {
14246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14247 }
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj = 0;
14256 wxGrid *arg1 = (wxGrid *) 0 ;
14257 int arg2 ;
14258 int arg3 ;
14259 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14260 void *argp1 = 0 ;
14261 int res1 = 0 ;
14262 int val2 ;
14263 int ecode2 = 0 ;
14264 int val3 ;
14265 int ecode3 = 0 ;
14266 void *argp4 = 0 ;
14267 int res4 = 0 ;
14268 PyObject * obj0 = 0 ;
14269 PyObject * obj1 = 0 ;
14270 PyObject * obj2 = 0 ;
14271 PyObject * obj3 = 0 ;
14272 char * kwnames[] = {
14273 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14274 };
14275
14276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14278 if (!SWIG_IsOK(res1)) {
14279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14280 }
14281 arg1 = reinterpret_cast< wxGrid * >(argp1);
14282 ecode2 = SWIG_AsVal_int(obj1, &val2);
14283 if (!SWIG_IsOK(ecode2)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14285 }
14286 arg2 = static_cast< int >(val2);
14287 ecode3 = SWIG_AsVal_int(obj2, &val3);
14288 if (!SWIG_IsOK(ecode3)) {
14289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14290 }
14291 arg3 = static_cast< int >(val3);
14292 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14293 if (!SWIG_IsOK(res4)) {
14294 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14295 }
14296 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14297 {
14298 PyThreadState* __tstate = wxPyBeginAllowThreads();
14299 (arg1)->SetAttr(arg2,arg3,arg4);
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 resultobj = SWIG_Py_Void();
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj = 0;
14312 wxGrid *arg1 = (wxGrid *) 0 ;
14313 int arg2 ;
14314 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14315 void *argp1 = 0 ;
14316 int res1 = 0 ;
14317 int val2 ;
14318 int ecode2 = 0 ;
14319 void *argp3 = 0 ;
14320 int res3 = 0 ;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 PyObject * obj2 = 0 ;
14324 char * kwnames[] = {
14325 (char *) "self",(char *) "row",(char *) "attr", NULL
14326 };
14327
14328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14330 if (!SWIG_IsOK(res1)) {
14331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14332 }
14333 arg1 = reinterpret_cast< wxGrid * >(argp1);
14334 ecode2 = SWIG_AsVal_int(obj1, &val2);
14335 if (!SWIG_IsOK(ecode2)) {
14336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14337 }
14338 arg2 = static_cast< int >(val2);
14339 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14340 if (!SWIG_IsOK(res3)) {
14341 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14342 }
14343 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 (arg1)->SetRowAttr(arg2,arg3);
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 resultobj = SWIG_Py_Void();
14351 return resultobj;
14352 fail:
14353 return NULL;
14354 }
14355
14356
14357 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14358 PyObject *resultobj = 0;
14359 wxGrid *arg1 = (wxGrid *) 0 ;
14360 int arg2 ;
14361 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14362 void *argp1 = 0 ;
14363 int res1 = 0 ;
14364 int val2 ;
14365 int ecode2 = 0 ;
14366 void *argp3 = 0 ;
14367 int res3 = 0 ;
14368 PyObject * obj0 = 0 ;
14369 PyObject * obj1 = 0 ;
14370 PyObject * obj2 = 0 ;
14371 char * kwnames[] = {
14372 (char *) "self",(char *) "col",(char *) "attr", NULL
14373 };
14374
14375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14377 if (!SWIG_IsOK(res1)) {
14378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14379 }
14380 arg1 = reinterpret_cast< wxGrid * >(argp1);
14381 ecode2 = SWIG_AsVal_int(obj1, &val2);
14382 if (!SWIG_IsOK(ecode2)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14384 }
14385 arg2 = static_cast< int >(val2);
14386 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14387 if (!SWIG_IsOK(res3)) {
14388 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14389 }
14390 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 (arg1)->SetColAttr(arg2,arg3);
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 resultobj = SWIG_Py_Void();
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj = 0;
14406 wxGrid *arg1 = (wxGrid *) 0 ;
14407 int arg2 ;
14408 int arg3 ;
14409 wxGridCellAttr *result = 0 ;
14410 void *argp1 = 0 ;
14411 int res1 = 0 ;
14412 int val2 ;
14413 int ecode2 = 0 ;
14414 int val3 ;
14415 int ecode3 = 0 ;
14416 PyObject * obj0 = 0 ;
14417 PyObject * obj1 = 0 ;
14418 PyObject * obj2 = 0 ;
14419 char * kwnames[] = {
14420 (char *) "self",(char *) "row",(char *) "col", NULL
14421 };
14422
14423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14425 if (!SWIG_IsOK(res1)) {
14426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14427 }
14428 arg1 = reinterpret_cast< wxGrid * >(argp1);
14429 ecode2 = SWIG_AsVal_int(obj1, &val2);
14430 if (!SWIG_IsOK(ecode2)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14432 }
14433 arg2 = static_cast< int >(val2);
14434 ecode3 = SWIG_AsVal_int(obj2, &val3);
14435 if (!SWIG_IsOK(ecode3)) {
14436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14437 }
14438 arg3 = static_cast< int >(val3);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 {
14446 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14447 }
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj = 0;
14456 wxGrid *arg1 = (wxGrid *) 0 ;
14457 int arg2 ;
14458 void *argp1 = 0 ;
14459 int res1 = 0 ;
14460 int val2 ;
14461 int ecode2 = 0 ;
14462 PyObject * obj0 = 0 ;
14463 PyObject * obj1 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "self",(char *) "col", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14472 }
14473 arg1 = reinterpret_cast< wxGrid * >(argp1);
14474 ecode2 = SWIG_AsVal_int(obj1, &val2);
14475 if (!SWIG_IsOK(ecode2)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14477 }
14478 arg2 = static_cast< int >(val2);
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 (arg1)->SetColFormatBool(arg2);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj = 0;
14494 wxGrid *arg1 = (wxGrid *) 0 ;
14495 int arg2 ;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 int val2 ;
14499 int ecode2 = 0 ;
14500 PyObject * obj0 = 0 ;
14501 PyObject * obj1 = 0 ;
14502 char * kwnames[] = {
14503 (char *) "self",(char *) "col", NULL
14504 };
14505
14506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14508 if (!SWIG_IsOK(res1)) {
14509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14510 }
14511 arg1 = reinterpret_cast< wxGrid * >(argp1);
14512 ecode2 = SWIG_AsVal_int(obj1, &val2);
14513 if (!SWIG_IsOK(ecode2)) {
14514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14515 }
14516 arg2 = static_cast< int >(val2);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 (arg1)->SetColFormatNumber(arg2);
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = SWIG_Py_Void();
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj = 0;
14532 wxGrid *arg1 = (wxGrid *) 0 ;
14533 int arg2 ;
14534 int arg3 = (int) -1 ;
14535 int arg4 = (int) -1 ;
14536 void *argp1 = 0 ;
14537 int res1 = 0 ;
14538 int val2 ;
14539 int ecode2 = 0 ;
14540 int val3 ;
14541 int ecode3 = 0 ;
14542 int val4 ;
14543 int ecode4 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 PyObject * obj3 = 0 ;
14548 char * kwnames[] = {
14549 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14550 };
14551
14552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14554 if (!SWIG_IsOK(res1)) {
14555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14556 }
14557 arg1 = reinterpret_cast< wxGrid * >(argp1);
14558 ecode2 = SWIG_AsVal_int(obj1, &val2);
14559 if (!SWIG_IsOK(ecode2)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14561 }
14562 arg2 = static_cast< int >(val2);
14563 if (obj2) {
14564 ecode3 = SWIG_AsVal_int(obj2, &val3);
14565 if (!SWIG_IsOK(ecode3)) {
14566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14567 }
14568 arg3 = static_cast< int >(val3);
14569 }
14570 if (obj3) {
14571 ecode4 = SWIG_AsVal_int(obj3, &val4);
14572 if (!SWIG_IsOK(ecode4)) {
14573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14574 }
14575 arg4 = static_cast< int >(val4);
14576 }
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 resultobj = SWIG_Py_Void();
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj = 0;
14592 wxGrid *arg1 = (wxGrid *) 0 ;
14593 int arg2 ;
14594 wxString *arg3 = 0 ;
14595 void *argp1 = 0 ;
14596 int res1 = 0 ;
14597 int val2 ;
14598 int ecode2 = 0 ;
14599 bool temp3 = false ;
14600 PyObject * obj0 = 0 ;
14601 PyObject * obj1 = 0 ;
14602 PyObject * obj2 = 0 ;
14603 char * kwnames[] = {
14604 (char *) "self",(char *) "col",(char *) "typeName", NULL
14605 };
14606
14607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14609 if (!SWIG_IsOK(res1)) {
14610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14611 }
14612 arg1 = reinterpret_cast< wxGrid * >(argp1);
14613 ecode2 = SWIG_AsVal_int(obj1, &val2);
14614 if (!SWIG_IsOK(ecode2)) {
14615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14616 }
14617 arg2 = static_cast< int >(val2);
14618 {
14619 arg3 = wxString_in_helper(obj2);
14620 if (arg3 == NULL) SWIG_fail;
14621 temp3 = true;
14622 }
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 resultobj = SWIG_Py_Void();
14630 {
14631 if (temp3)
14632 delete arg3;
14633 }
14634 return resultobj;
14635 fail:
14636 {
14637 if (temp3)
14638 delete arg3;
14639 }
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxGrid *arg1 = (wxGrid *) 0 ;
14647 bool arg2 = (bool) true ;
14648 void *argp1 = 0 ;
14649 int res1 = 0 ;
14650 bool val2 ;
14651 int ecode2 = 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 char * kwnames[] = {
14655 (char *) "self",(char *) "enable", NULL
14656 };
14657
14658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14662 }
14663 arg1 = reinterpret_cast< wxGrid * >(argp1);
14664 if (obj1) {
14665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14666 if (!SWIG_IsOK(ecode2)) {
14667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14668 }
14669 arg2 = static_cast< bool >(val2);
14670 }
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 (arg1)->EnableGridLines(arg2);
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = SWIG_Py_Void();
14678 return resultobj;
14679 fail:
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14685 PyObject *resultobj = 0;
14686 wxGrid *arg1 = (wxGrid *) 0 ;
14687 bool result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 PyObject *swig_obj[1] ;
14691
14692 if (!args) SWIG_fail;
14693 swig_obj[0] = args;
14694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14695 if (!SWIG_IsOK(res1)) {
14696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14697 }
14698 arg1 = reinterpret_cast< wxGrid * >(argp1);
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (bool)(arg1)->GridLinesEnabled();
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 {
14706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14707 }
14708 return resultobj;
14709 fail:
14710 return NULL;
14711 }
14712
14713
14714 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14715 PyObject *resultobj = 0;
14716 wxGrid *arg1 = (wxGrid *) 0 ;
14717 int result;
14718 void *argp1 = 0 ;
14719 int res1 = 0 ;
14720 PyObject *swig_obj[1] ;
14721
14722 if (!args) SWIG_fail;
14723 swig_obj[0] = args;
14724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14725 if (!SWIG_IsOK(res1)) {
14726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14727 }
14728 arg1 = reinterpret_cast< wxGrid * >(argp1);
14729 {
14730 PyThreadState* __tstate = wxPyBeginAllowThreads();
14731 result = (int)(arg1)->GetDefaultRowSize();
14732 wxPyEndAllowThreads(__tstate);
14733 if (PyErr_Occurred()) SWIG_fail;
14734 }
14735 resultobj = SWIG_From_int(static_cast< int >(result));
14736 return resultobj;
14737 fail:
14738 return NULL;
14739 }
14740
14741
14742 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj = 0;
14744 wxGrid *arg1 = (wxGrid *) 0 ;
14745 int arg2 ;
14746 int result;
14747 void *argp1 = 0 ;
14748 int res1 = 0 ;
14749 int val2 ;
14750 int ecode2 = 0 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "row", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14761 }
14762 arg1 = reinterpret_cast< wxGrid * >(argp1);
14763 ecode2 = SWIG_AsVal_int(obj1, &val2);
14764 if (!SWIG_IsOK(ecode2)) {
14765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14766 }
14767 arg2 = static_cast< int >(val2);
14768 {
14769 PyThreadState* __tstate = wxPyBeginAllowThreads();
14770 result = (int)(arg1)->GetRowSize(arg2);
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 resultobj = SWIG_From_int(static_cast< int >(result));
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14782 PyObject *resultobj = 0;
14783 wxGrid *arg1 = (wxGrid *) 0 ;
14784 int result;
14785 void *argp1 = 0 ;
14786 int res1 = 0 ;
14787 PyObject *swig_obj[1] ;
14788
14789 if (!args) SWIG_fail;
14790 swig_obj[0] = args;
14791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14792 if (!SWIG_IsOK(res1)) {
14793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14794 }
14795 arg1 = reinterpret_cast< wxGrid * >(argp1);
14796 {
14797 PyThreadState* __tstate = wxPyBeginAllowThreads();
14798 result = (int)(arg1)->GetDefaultColSize();
14799 wxPyEndAllowThreads(__tstate);
14800 if (PyErr_Occurred()) SWIG_fail;
14801 }
14802 resultobj = SWIG_From_int(static_cast< int >(result));
14803 return resultobj;
14804 fail:
14805 return NULL;
14806 }
14807
14808
14809 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14810 PyObject *resultobj = 0;
14811 wxGrid *arg1 = (wxGrid *) 0 ;
14812 int arg2 ;
14813 int result;
14814 void *argp1 = 0 ;
14815 int res1 = 0 ;
14816 int val2 ;
14817 int ecode2 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 char * kwnames[] = {
14821 (char *) "self",(char *) "col", NULL
14822 };
14823
14824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14826 if (!SWIG_IsOK(res1)) {
14827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14828 }
14829 arg1 = reinterpret_cast< wxGrid * >(argp1);
14830 ecode2 = SWIG_AsVal_int(obj1, &val2);
14831 if (!SWIG_IsOK(ecode2)) {
14832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14833 }
14834 arg2 = static_cast< int >(val2);
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (int)(arg1)->GetColSize(arg2);
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 resultobj = SWIG_From_int(static_cast< int >(result));
14842 return resultobj;
14843 fail:
14844 return NULL;
14845 }
14846
14847
14848 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14849 PyObject *resultobj = 0;
14850 wxGrid *arg1 = (wxGrid *) 0 ;
14851 wxColour result;
14852 void *argp1 = 0 ;
14853 int res1 = 0 ;
14854 PyObject *swig_obj[1] ;
14855
14856 if (!args) SWIG_fail;
14857 swig_obj[0] = args;
14858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14859 if (!SWIG_IsOK(res1)) {
14860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14861 }
14862 arg1 = reinterpret_cast< wxGrid * >(argp1);
14863 {
14864 PyThreadState* __tstate = wxPyBeginAllowThreads();
14865 result = (arg1)->GetDefaultCellBackgroundColour();
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14870 return resultobj;
14871 fail:
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxGrid *arg1 = (wxGrid *) 0 ;
14879 int arg2 ;
14880 int arg3 ;
14881 wxColour result;
14882 void *argp1 = 0 ;
14883 int res1 = 0 ;
14884 int val2 ;
14885 int ecode2 = 0 ;
14886 int val3 ;
14887 int ecode3 = 0 ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 PyObject * obj2 = 0 ;
14891 char * kwnames[] = {
14892 (char *) "self",(char *) "row",(char *) "col", NULL
14893 };
14894
14895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14897 if (!SWIG_IsOK(res1)) {
14898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14899 }
14900 arg1 = reinterpret_cast< wxGrid * >(argp1);
14901 ecode2 = SWIG_AsVal_int(obj1, &val2);
14902 if (!SWIG_IsOK(ecode2)) {
14903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14904 }
14905 arg2 = static_cast< int >(val2);
14906 ecode3 = SWIG_AsVal_int(obj2, &val3);
14907 if (!SWIG_IsOK(ecode3)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14909 }
14910 arg3 = static_cast< int >(val3);
14911 {
14912 PyThreadState* __tstate = wxPyBeginAllowThreads();
14913 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14914 wxPyEndAllowThreads(__tstate);
14915 if (PyErr_Occurred()) SWIG_fail;
14916 }
14917 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14918 return resultobj;
14919 fail:
14920 return NULL;
14921 }
14922
14923
14924 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14925 PyObject *resultobj = 0;
14926 wxGrid *arg1 = (wxGrid *) 0 ;
14927 wxColour result;
14928 void *argp1 = 0 ;
14929 int res1 = 0 ;
14930 PyObject *swig_obj[1] ;
14931
14932 if (!args) SWIG_fail;
14933 swig_obj[0] = args;
14934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14935 if (!SWIG_IsOK(res1)) {
14936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14937 }
14938 arg1 = reinterpret_cast< wxGrid * >(argp1);
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 result = (arg1)->GetDefaultCellTextColour();
14942 wxPyEndAllowThreads(__tstate);
14943 if (PyErr_Occurred()) SWIG_fail;
14944 }
14945 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj = 0;
14954 wxGrid *arg1 = (wxGrid *) 0 ;
14955 int arg2 ;
14956 int arg3 ;
14957 wxColour result;
14958 void *argp1 = 0 ;
14959 int res1 = 0 ;
14960 int val2 ;
14961 int ecode2 = 0 ;
14962 int val3 ;
14963 int ecode3 = 0 ;
14964 PyObject * obj0 = 0 ;
14965 PyObject * obj1 = 0 ;
14966 PyObject * obj2 = 0 ;
14967 char * kwnames[] = {
14968 (char *) "self",(char *) "row",(char *) "col", NULL
14969 };
14970
14971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14973 if (!SWIG_IsOK(res1)) {
14974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14975 }
14976 arg1 = reinterpret_cast< wxGrid * >(argp1);
14977 ecode2 = SWIG_AsVal_int(obj1, &val2);
14978 if (!SWIG_IsOK(ecode2)) {
14979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14980 }
14981 arg2 = static_cast< int >(val2);
14982 ecode3 = SWIG_AsVal_int(obj2, &val3);
14983 if (!SWIG_IsOK(ecode3)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14985 }
14986 arg3 = static_cast< int >(val3);
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (arg1)->GetCellTextColour(arg2,arg3);
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15001 PyObject *resultobj = 0;
15002 wxGrid *arg1 = (wxGrid *) 0 ;
15003 wxFont result;
15004 void *argp1 = 0 ;
15005 int res1 = 0 ;
15006 PyObject *swig_obj[1] ;
15007
15008 if (!args) SWIG_fail;
15009 swig_obj[0] = args;
15010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15011 if (!SWIG_IsOK(res1)) {
15012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15013 }
15014 arg1 = reinterpret_cast< wxGrid * >(argp1);
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (arg1)->GetDefaultCellFont();
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxGrid *arg1 = (wxGrid *) 0 ;
15031 int arg2 ;
15032 int arg3 ;
15033 wxFont result;
15034 void *argp1 = 0 ;
15035 int res1 = 0 ;
15036 int val2 ;
15037 int ecode2 = 0 ;
15038 int val3 ;
15039 int ecode3 = 0 ;
15040 PyObject * obj0 = 0 ;
15041 PyObject * obj1 = 0 ;
15042 PyObject * obj2 = 0 ;
15043 char * kwnames[] = {
15044 (char *) "self",(char *) "row",(char *) "col", NULL
15045 };
15046
15047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15049 if (!SWIG_IsOK(res1)) {
15050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15051 }
15052 arg1 = reinterpret_cast< wxGrid * >(argp1);
15053 ecode2 = SWIG_AsVal_int(obj1, &val2);
15054 if (!SWIG_IsOK(ecode2)) {
15055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15056 }
15057 arg2 = static_cast< int >(val2);
15058 ecode3 = SWIG_AsVal_int(obj2, &val3);
15059 if (!SWIG_IsOK(ecode3)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15061 }
15062 arg3 = static_cast< int >(val3);
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (arg1)->GetCellFont(arg2,arg3);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxGrid *arg1 = (wxGrid *) 0 ;
15079 int *arg2 = (int *) 0 ;
15080 int *arg3 = (int *) 0 ;
15081 void *argp1 = 0 ;
15082 int res1 = 0 ;
15083 int temp2 ;
15084 int res2 = SWIG_TMPOBJ ;
15085 int temp3 ;
15086 int res3 = SWIG_TMPOBJ ;
15087 PyObject *swig_obj[1] ;
15088
15089 arg2 = &temp2;
15090 arg3 = &temp3;
15091 if (!args) SWIG_fail;
15092 swig_obj[0] = args;
15093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15096 }
15097 arg1 = reinterpret_cast< wxGrid * >(argp1);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 resultobj = SWIG_Py_Void();
15105 if (SWIG_IsTmpObj(res2)) {
15106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15107 } else {
15108 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15110 }
15111 if (SWIG_IsTmpObj(res3)) {
15112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15113 } else {
15114 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15116 }
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = 0;
15125 wxGrid *arg1 = (wxGrid *) 0 ;
15126 int arg2 ;
15127 int arg3 ;
15128 int *arg4 = (int *) 0 ;
15129 int *arg5 = (int *) 0 ;
15130 void *argp1 = 0 ;
15131 int res1 = 0 ;
15132 int val2 ;
15133 int ecode2 = 0 ;
15134 int val3 ;
15135 int ecode3 = 0 ;
15136 int temp4 ;
15137 int res4 = SWIG_TMPOBJ ;
15138 int temp5 ;
15139 int res5 = SWIG_TMPOBJ ;
15140 PyObject * obj0 = 0 ;
15141 PyObject * obj1 = 0 ;
15142 PyObject * obj2 = 0 ;
15143 char * kwnames[] = {
15144 (char *) "self",(char *) "row",(char *) "col", NULL
15145 };
15146
15147 arg4 = &temp4;
15148 arg5 = &temp5;
15149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15153 }
15154 arg1 = reinterpret_cast< wxGrid * >(argp1);
15155 ecode2 = SWIG_AsVal_int(obj1, &val2);
15156 if (!SWIG_IsOK(ecode2)) {
15157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15158 }
15159 arg2 = static_cast< int >(val2);
15160 ecode3 = SWIG_AsVal_int(obj2, &val3);
15161 if (!SWIG_IsOK(ecode3)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15163 }
15164 arg3 = static_cast< int >(val3);
15165 {
15166 PyThreadState* __tstate = wxPyBeginAllowThreads();
15167 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15168 wxPyEndAllowThreads(__tstate);
15169 if (PyErr_Occurred()) SWIG_fail;
15170 }
15171 resultobj = SWIG_Py_Void();
15172 if (SWIG_IsTmpObj(res4)) {
15173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15174 } else {
15175 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15177 }
15178 if (SWIG_IsTmpObj(res5)) {
15179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15180 } else {
15181 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15183 }
15184 return resultobj;
15185 fail:
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15191 PyObject *resultobj = 0;
15192 wxGrid *arg1 = (wxGrid *) 0 ;
15193 bool result;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 PyObject *swig_obj[1] ;
15197
15198 if (!args) SWIG_fail;
15199 swig_obj[0] = args;
15200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15201 if (!SWIG_IsOK(res1)) {
15202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15203 }
15204 arg1 = reinterpret_cast< wxGrid * >(argp1);
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = (bool)(arg1)->GetDefaultCellOverflow();
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 {
15212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxGrid *arg1 = (wxGrid *) 0 ;
15223 int arg2 ;
15224 int arg3 ;
15225 bool result;
15226 void *argp1 = 0 ;
15227 int res1 = 0 ;
15228 int val2 ;
15229 int ecode2 = 0 ;
15230 int val3 ;
15231 int ecode3 = 0 ;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 PyObject * obj2 = 0 ;
15235 char * kwnames[] = {
15236 (char *) "self",(char *) "row",(char *) "col", NULL
15237 };
15238
15239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15243 }
15244 arg1 = reinterpret_cast< wxGrid * >(argp1);
15245 ecode2 = SWIG_AsVal_int(obj1, &val2);
15246 if (!SWIG_IsOK(ecode2)) {
15247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15248 }
15249 arg2 = static_cast< int >(val2);
15250 ecode3 = SWIG_AsVal_int(obj2, &val3);
15251 if (!SWIG_IsOK(ecode3)) {
15252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15253 }
15254 arg3 = static_cast< int >(val3);
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 {
15262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15263 }
15264 return resultobj;
15265 fail:
15266 return NULL;
15267 }
15268
15269
15270 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15271 PyObject *resultobj = 0;
15272 wxGrid *arg1 = (wxGrid *) 0 ;
15273 int arg2 ;
15274 int arg3 ;
15275 int *arg4 = (int *) 0 ;
15276 int *arg5 = (int *) 0 ;
15277 void *argp1 = 0 ;
15278 int res1 = 0 ;
15279 int val2 ;
15280 int ecode2 = 0 ;
15281 int val3 ;
15282 int ecode3 = 0 ;
15283 int temp4 ;
15284 int res4 = SWIG_TMPOBJ ;
15285 int temp5 ;
15286 int res5 = SWIG_TMPOBJ ;
15287 PyObject * obj0 = 0 ;
15288 PyObject * obj1 = 0 ;
15289 PyObject * obj2 = 0 ;
15290 char * kwnames[] = {
15291 (char *) "self",(char *) "row",(char *) "col", NULL
15292 };
15293
15294 arg4 = &temp4;
15295 arg5 = &temp5;
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15300 }
15301 arg1 = reinterpret_cast< wxGrid * >(argp1);
15302 ecode2 = SWIG_AsVal_int(obj1, &val2);
15303 if (!SWIG_IsOK(ecode2)) {
15304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15305 }
15306 arg2 = static_cast< int >(val2);
15307 ecode3 = SWIG_AsVal_int(obj2, &val3);
15308 if (!SWIG_IsOK(ecode3)) {
15309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15310 }
15311 arg3 = static_cast< int >(val3);
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_Py_Void();
15319 if (SWIG_IsTmpObj(res4)) {
15320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15321 } else {
15322 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15324 }
15325 if (SWIG_IsTmpObj(res5)) {
15326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15327 } else {
15328 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15330 }
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15338 PyObject *resultobj = 0;
15339 wxGrid *arg1 = (wxGrid *) 0 ;
15340 int arg2 ;
15341 bool arg3 = (bool) false ;
15342 void *argp1 = 0 ;
15343 int res1 = 0 ;
15344 int val2 ;
15345 int ecode2 = 0 ;
15346 bool val3 ;
15347 int ecode3 = 0 ;
15348 PyObject * obj0 = 0 ;
15349 PyObject * obj1 = 0 ;
15350 PyObject * obj2 = 0 ;
15351 char * kwnames[] = {
15352 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15353 };
15354
15355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15359 }
15360 arg1 = reinterpret_cast< wxGrid * >(argp1);
15361 ecode2 = SWIG_AsVal_int(obj1, &val2);
15362 if (!SWIG_IsOK(ecode2)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15364 }
15365 arg2 = static_cast< int >(val2);
15366 if (obj2) {
15367 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15368 if (!SWIG_IsOK(ecode3)) {
15369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15370 }
15371 arg3 = static_cast< bool >(val3);
15372 }
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 (arg1)->SetDefaultRowSize(arg2,arg3);
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 resultobj = SWIG_Py_Void();
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15387 PyObject *resultobj = 0;
15388 wxGrid *arg1 = (wxGrid *) 0 ;
15389 int arg2 ;
15390 int arg3 ;
15391 void *argp1 = 0 ;
15392 int res1 = 0 ;
15393 int val2 ;
15394 int ecode2 = 0 ;
15395 int val3 ;
15396 int ecode3 = 0 ;
15397 PyObject * obj0 = 0 ;
15398 PyObject * obj1 = 0 ;
15399 PyObject * obj2 = 0 ;
15400 char * kwnames[] = {
15401 (char *) "self",(char *) "row",(char *) "height", NULL
15402 };
15403
15404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15408 }
15409 arg1 = reinterpret_cast< wxGrid * >(argp1);
15410 ecode2 = SWIG_AsVal_int(obj1, &val2);
15411 if (!SWIG_IsOK(ecode2)) {
15412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15413 }
15414 arg2 = static_cast< int >(val2);
15415 ecode3 = SWIG_AsVal_int(obj2, &val3);
15416 if (!SWIG_IsOK(ecode3)) {
15417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15418 }
15419 arg3 = static_cast< int >(val3);
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 (arg1)->SetRowSize(arg2,arg3);
15423 wxPyEndAllowThreads(__tstate);
15424 if (PyErr_Occurred()) SWIG_fail;
15425 }
15426 resultobj = SWIG_Py_Void();
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj = 0;
15435 wxGrid *arg1 = (wxGrid *) 0 ;
15436 int arg2 ;
15437 bool arg3 = (bool) false ;
15438 void *argp1 = 0 ;
15439 int res1 = 0 ;
15440 int val2 ;
15441 int ecode2 = 0 ;
15442 bool val3 ;
15443 int ecode3 = 0 ;
15444 PyObject * obj0 = 0 ;
15445 PyObject * obj1 = 0 ;
15446 PyObject * obj2 = 0 ;
15447 char * kwnames[] = {
15448 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15453 if (!SWIG_IsOK(res1)) {
15454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15455 }
15456 arg1 = reinterpret_cast< wxGrid * >(argp1);
15457 ecode2 = SWIG_AsVal_int(obj1, &val2);
15458 if (!SWIG_IsOK(ecode2)) {
15459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15460 }
15461 arg2 = static_cast< int >(val2);
15462 if (obj2) {
15463 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15464 if (!SWIG_IsOK(ecode3)) {
15465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15466 }
15467 arg3 = static_cast< bool >(val3);
15468 }
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 (arg1)->SetDefaultColSize(arg2,arg3);
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 resultobj = SWIG_Py_Void();
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj = 0;
15484 wxGrid *arg1 = (wxGrid *) 0 ;
15485 int arg2 ;
15486 int arg3 ;
15487 void *argp1 = 0 ;
15488 int res1 = 0 ;
15489 int val2 ;
15490 int ecode2 = 0 ;
15491 int val3 ;
15492 int ecode3 = 0 ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 PyObject * obj2 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "col",(char *) "width", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15504 }
15505 arg1 = reinterpret_cast< wxGrid * >(argp1);
15506 ecode2 = SWIG_AsVal_int(obj1, &val2);
15507 if (!SWIG_IsOK(ecode2)) {
15508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15509 }
15510 arg2 = static_cast< int >(val2);
15511 ecode3 = SWIG_AsVal_int(obj2, &val3);
15512 if (!SWIG_IsOK(ecode3)) {
15513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15514 }
15515 arg3 = static_cast< int >(val3);
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 (arg1)->SetColSize(arg2,arg3);
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 resultobj = SWIG_Py_Void();
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj = 0;
15531 wxGrid *arg1 = (wxGrid *) 0 ;
15532 int arg2 ;
15533 int result;
15534 void *argp1 = 0 ;
15535 int res1 = 0 ;
15536 int val2 ;
15537 int ecode2 = 0 ;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 char * kwnames[] = {
15541 (char *) "self",(char *) "colPos", NULL
15542 };
15543
15544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15546 if (!SWIG_IsOK(res1)) {
15547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15548 }
15549 arg1 = reinterpret_cast< wxGrid * >(argp1);
15550 ecode2 = SWIG_AsVal_int(obj1, &val2);
15551 if (!SWIG_IsOK(ecode2)) {
15552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15553 }
15554 arg2 = static_cast< int >(val2);
15555 {
15556 PyThreadState* __tstate = wxPyBeginAllowThreads();
15557 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 resultobj = SWIG_From_int(static_cast< int >(result));
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15569 PyObject *resultobj = 0;
15570 wxGrid *arg1 = (wxGrid *) 0 ;
15571 int arg2 ;
15572 int arg3 ;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 int val2 ;
15576 int ecode2 = 0 ;
15577 int val3 ;
15578 int ecode3 = 0 ;
15579 PyObject * obj0 = 0 ;
15580 PyObject * obj1 = 0 ;
15581 PyObject * obj2 = 0 ;
15582 char * kwnames[] = {
15583 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15584 };
15585
15586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15588 if (!SWIG_IsOK(res1)) {
15589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15590 }
15591 arg1 = reinterpret_cast< wxGrid * >(argp1);
15592 ecode2 = SWIG_AsVal_int(obj1, &val2);
15593 if (!SWIG_IsOK(ecode2)) {
15594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15595 }
15596 arg2 = static_cast< int >(val2);
15597 ecode3 = SWIG_AsVal_int(obj2, &val3);
15598 if (!SWIG_IsOK(ecode3)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15600 }
15601 arg3 = static_cast< int >(val3);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 (arg1)->SetColPos(arg2,arg3);
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = SWIG_Py_Void();
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15616 PyObject *resultobj = 0;
15617 wxGrid *arg1 = (wxGrid *) 0 ;
15618 int arg2 ;
15619 int result;
15620 void *argp1 = 0 ;
15621 int res1 = 0 ;
15622 int val2 ;
15623 int ecode2 = 0 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "colID", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15634 }
15635 arg1 = reinterpret_cast< wxGrid * >(argp1);
15636 ecode2 = SWIG_AsVal_int(obj1, &val2);
15637 if (!SWIG_IsOK(ecode2)) {
15638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15639 }
15640 arg2 = static_cast< int >(val2);
15641 {
15642 PyThreadState* __tstate = wxPyBeginAllowThreads();
15643 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15644 wxPyEndAllowThreads(__tstate);
15645 if (PyErr_Occurred()) SWIG_fail;
15646 }
15647 resultobj = SWIG_From_int(static_cast< int >(result));
15648 return resultobj;
15649 fail:
15650 return NULL;
15651 }
15652
15653
15654 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15655 PyObject *resultobj = 0;
15656 wxGrid *arg1 = (wxGrid *) 0 ;
15657 int arg2 ;
15658 bool arg3 = (bool) true ;
15659 void *argp1 = 0 ;
15660 int res1 = 0 ;
15661 int val2 ;
15662 int ecode2 = 0 ;
15663 bool val3 ;
15664 int ecode3 = 0 ;
15665 PyObject * obj0 = 0 ;
15666 PyObject * obj1 = 0 ;
15667 PyObject * obj2 = 0 ;
15668 char * kwnames[] = {
15669 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15670 };
15671
15672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15674 if (!SWIG_IsOK(res1)) {
15675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15676 }
15677 arg1 = reinterpret_cast< wxGrid * >(argp1);
15678 ecode2 = SWIG_AsVal_int(obj1, &val2);
15679 if (!SWIG_IsOK(ecode2)) {
15680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15681 }
15682 arg2 = static_cast< int >(val2);
15683 if (obj2) {
15684 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15685 if (!SWIG_IsOK(ecode3)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15687 }
15688 arg3 = static_cast< bool >(val3);
15689 }
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 (arg1)->AutoSizeColumn(arg2,arg3);
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_Py_Void();
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj = 0;
15705 wxGrid *arg1 = (wxGrid *) 0 ;
15706 int arg2 ;
15707 bool arg3 = (bool) true ;
15708 void *argp1 = 0 ;
15709 int res1 = 0 ;
15710 int val2 ;
15711 int ecode2 = 0 ;
15712 bool val3 ;
15713 int ecode3 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 PyObject * obj2 = 0 ;
15717 char * kwnames[] = {
15718 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15719 };
15720
15721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15723 if (!SWIG_IsOK(res1)) {
15724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15725 }
15726 arg1 = reinterpret_cast< wxGrid * >(argp1);
15727 ecode2 = SWIG_AsVal_int(obj1, &val2);
15728 if (!SWIG_IsOK(ecode2)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15730 }
15731 arg2 = static_cast< int >(val2);
15732 if (obj2) {
15733 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15734 if (!SWIG_IsOK(ecode3)) {
15735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15736 }
15737 arg3 = static_cast< bool >(val3);
15738 }
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 (arg1)->AutoSizeRow(arg2,arg3);
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 resultobj = SWIG_Py_Void();
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15753 PyObject *resultobj = 0;
15754 wxGrid *arg1 = (wxGrid *) 0 ;
15755 bool arg2 = (bool) true ;
15756 void *argp1 = 0 ;
15757 int res1 = 0 ;
15758 bool val2 ;
15759 int ecode2 = 0 ;
15760 PyObject * obj0 = 0 ;
15761 PyObject * obj1 = 0 ;
15762 char * kwnames[] = {
15763 (char *) "self",(char *) "setAsMin", NULL
15764 };
15765
15766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) 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_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15770 }
15771 arg1 = reinterpret_cast< wxGrid * >(argp1);
15772 if (obj1) {
15773 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15774 if (!SWIG_IsOK(ecode2)) {
15775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15776 }
15777 arg2 = static_cast< bool >(val2);
15778 }
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 (arg1)->AutoSizeColumns(arg2);
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 resultobj = SWIG_Py_Void();
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj = 0;
15794 wxGrid *arg1 = (wxGrid *) 0 ;
15795 bool arg2 = (bool) true ;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 bool val2 ;
15799 int ecode2 = 0 ;
15800 PyObject * obj0 = 0 ;
15801 PyObject * obj1 = 0 ;
15802 char * kwnames[] = {
15803 (char *) "self",(char *) "setAsMin", NULL
15804 };
15805
15806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15808 if (!SWIG_IsOK(res1)) {
15809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15810 }
15811 arg1 = reinterpret_cast< wxGrid * >(argp1);
15812 if (obj1) {
15813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15814 if (!SWIG_IsOK(ecode2)) {
15815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15816 }
15817 arg2 = static_cast< bool >(val2);
15818 }
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 (arg1)->AutoSizeRows(arg2);
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_Py_Void();
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15833 PyObject *resultobj = 0;
15834 wxGrid *arg1 = (wxGrid *) 0 ;
15835 void *argp1 = 0 ;
15836 int res1 = 0 ;
15837 PyObject *swig_obj[1] ;
15838
15839 if (!args) SWIG_fail;
15840 swig_obj[0] = args;
15841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15844 }
15845 arg1 = reinterpret_cast< wxGrid * >(argp1);
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 (arg1)->AutoSize();
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_Py_Void();
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 wxGrid *arg1 = (wxGrid *) 0 ;
15862 int arg2 ;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 int val2 ;
15866 int ecode2 = 0 ;
15867 PyObject * obj0 = 0 ;
15868 PyObject * obj1 = 0 ;
15869 char * kwnames[] = {
15870 (char *) "self",(char *) "row", NULL
15871 };
15872
15873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15875 if (!SWIG_IsOK(res1)) {
15876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15877 }
15878 arg1 = reinterpret_cast< wxGrid * >(argp1);
15879 ecode2 = SWIG_AsVal_int(obj1, &val2);
15880 if (!SWIG_IsOK(ecode2)) {
15881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15882 }
15883 arg2 = static_cast< int >(val2);
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 (arg1)->AutoSizeRowLabelSize(arg2);
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_Py_Void();
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj = 0;
15899 wxGrid *arg1 = (wxGrid *) 0 ;
15900 int arg2 ;
15901 void *argp1 = 0 ;
15902 int res1 = 0 ;
15903 int val2 ;
15904 int ecode2 = 0 ;
15905 PyObject * obj0 = 0 ;
15906 PyObject * obj1 = 0 ;
15907 char * kwnames[] = {
15908 (char *) "self",(char *) "col", NULL
15909 };
15910
15911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15913 if (!SWIG_IsOK(res1)) {
15914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15915 }
15916 arg1 = reinterpret_cast< wxGrid * >(argp1);
15917 ecode2 = SWIG_AsVal_int(obj1, &val2);
15918 if (!SWIG_IsOK(ecode2)) {
15919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15920 }
15921 arg2 = static_cast< int >(val2);
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 (arg1)->AutoSizeColLabelSize(arg2);
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_Py_Void();
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 wxGrid *arg1 = (wxGrid *) 0 ;
15938 int arg2 ;
15939 int arg3 ;
15940 void *argp1 = 0 ;
15941 int res1 = 0 ;
15942 int val2 ;
15943 int ecode2 = 0 ;
15944 int val3 ;
15945 int ecode3 = 0 ;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 PyObject * obj2 = 0 ;
15949 char * kwnames[] = {
15950 (char *) "self",(char *) "col",(char *) "width", NULL
15951 };
15952
15953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15955 if (!SWIG_IsOK(res1)) {
15956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15957 }
15958 arg1 = reinterpret_cast< wxGrid * >(argp1);
15959 ecode2 = SWIG_AsVal_int(obj1, &val2);
15960 if (!SWIG_IsOK(ecode2)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15962 }
15963 arg2 = static_cast< int >(val2);
15964 ecode3 = SWIG_AsVal_int(obj2, &val3);
15965 if (!SWIG_IsOK(ecode3)) {
15966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15967 }
15968 arg3 = static_cast< int >(val3);
15969 {
15970 PyThreadState* __tstate = wxPyBeginAllowThreads();
15971 (arg1)->SetColMinimalWidth(arg2,arg3);
15972 wxPyEndAllowThreads(__tstate);
15973 if (PyErr_Occurred()) SWIG_fail;
15974 }
15975 resultobj = SWIG_Py_Void();
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj = 0;
15984 wxGrid *arg1 = (wxGrid *) 0 ;
15985 int arg2 ;
15986 int arg3 ;
15987 void *argp1 = 0 ;
15988 int res1 = 0 ;
15989 int val2 ;
15990 int ecode2 = 0 ;
15991 int val3 ;
15992 int ecode3 = 0 ;
15993 PyObject * obj0 = 0 ;
15994 PyObject * obj1 = 0 ;
15995 PyObject * obj2 = 0 ;
15996 char * kwnames[] = {
15997 (char *) "self",(char *) "row",(char *) "width", NULL
15998 };
15999
16000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16004 }
16005 arg1 = reinterpret_cast< wxGrid * >(argp1);
16006 ecode2 = SWIG_AsVal_int(obj1, &val2);
16007 if (!SWIG_IsOK(ecode2)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16009 }
16010 arg2 = static_cast< int >(val2);
16011 ecode3 = SWIG_AsVal_int(obj2, &val3);
16012 if (!SWIG_IsOK(ecode3)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16014 }
16015 arg3 = static_cast< int >(val3);
16016 {
16017 PyThreadState* __tstate = wxPyBeginAllowThreads();
16018 (arg1)->SetRowMinimalHeight(arg2,arg3);
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 resultobj = SWIG_Py_Void();
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj = 0;
16031 wxGrid *arg1 = (wxGrid *) 0 ;
16032 int arg2 ;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 int val2 ;
16036 int ecode2 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char * kwnames[] = {
16040 (char *) "self",(char *) "width", NULL
16041 };
16042
16043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16047 }
16048 arg1 = reinterpret_cast< wxGrid * >(argp1);
16049 ecode2 = SWIG_AsVal_int(obj1, &val2);
16050 if (!SWIG_IsOK(ecode2)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16052 }
16053 arg2 = static_cast< int >(val2);
16054 {
16055 PyThreadState* __tstate = wxPyBeginAllowThreads();
16056 (arg1)->SetColMinimalAcceptableWidth(arg2);
16057 wxPyEndAllowThreads(__tstate);
16058 if (PyErr_Occurred()) SWIG_fail;
16059 }
16060 resultobj = SWIG_Py_Void();
16061 return resultobj;
16062 fail:
16063 return NULL;
16064 }
16065
16066
16067 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16068 PyObject *resultobj = 0;
16069 wxGrid *arg1 = (wxGrid *) 0 ;
16070 int arg2 ;
16071 void *argp1 = 0 ;
16072 int res1 = 0 ;
16073 int val2 ;
16074 int ecode2 = 0 ;
16075 PyObject * obj0 = 0 ;
16076 PyObject * obj1 = 0 ;
16077 char * kwnames[] = {
16078 (char *) "self",(char *) "width", NULL
16079 };
16080
16081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16083 if (!SWIG_IsOK(res1)) {
16084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16085 }
16086 arg1 = reinterpret_cast< wxGrid * >(argp1);
16087 ecode2 = SWIG_AsVal_int(obj1, &val2);
16088 if (!SWIG_IsOK(ecode2)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16090 }
16091 arg2 = static_cast< int >(val2);
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 resultobj = SWIG_Py_Void();
16099 return resultobj;
16100 fail:
16101 return NULL;
16102 }
16103
16104
16105 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16106 PyObject *resultobj = 0;
16107 wxGrid *arg1 = (wxGrid *) 0 ;
16108 int result;
16109 void *argp1 = 0 ;
16110 int res1 = 0 ;
16111 PyObject *swig_obj[1] ;
16112
16113 if (!args) SWIG_fail;
16114 swig_obj[0] = args;
16115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16116 if (!SWIG_IsOK(res1)) {
16117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16118 }
16119 arg1 = reinterpret_cast< wxGrid * >(argp1);
16120 {
16121 PyThreadState* __tstate = wxPyBeginAllowThreads();
16122 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16123 wxPyEndAllowThreads(__tstate);
16124 if (PyErr_Occurred()) SWIG_fail;
16125 }
16126 resultobj = SWIG_From_int(static_cast< int >(result));
16127 return resultobj;
16128 fail:
16129 return NULL;
16130 }
16131
16132
16133 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16134 PyObject *resultobj = 0;
16135 wxGrid *arg1 = (wxGrid *) 0 ;
16136 int result;
16137 void *argp1 = 0 ;
16138 int res1 = 0 ;
16139 PyObject *swig_obj[1] ;
16140
16141 if (!args) SWIG_fail;
16142 swig_obj[0] = args;
16143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16144 if (!SWIG_IsOK(res1)) {
16145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16146 }
16147 arg1 = reinterpret_cast< wxGrid * >(argp1);
16148 {
16149 PyThreadState* __tstate = wxPyBeginAllowThreads();
16150 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16151 wxPyEndAllowThreads(__tstate);
16152 if (PyErr_Occurred()) SWIG_fail;
16153 }
16154 resultobj = SWIG_From_int(static_cast< int >(result));
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16162 PyObject *resultobj = 0;
16163 wxGrid *arg1 = (wxGrid *) 0 ;
16164 wxColour *arg2 = 0 ;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 wxColour temp2 ;
16168 PyObject * obj0 = 0 ;
16169 PyObject * obj1 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *)"arg2", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16178 }
16179 arg1 = reinterpret_cast< wxGrid * >(argp1);
16180 {
16181 arg2 = &temp2;
16182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16183 }
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 resultobj = SWIG_Py_Void();
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj = 0;
16199 wxGrid *arg1 = (wxGrid *) 0 ;
16200 int arg2 ;
16201 int arg3 ;
16202 wxColour *arg4 = 0 ;
16203 void *argp1 = 0 ;
16204 int res1 = 0 ;
16205 int val2 ;
16206 int ecode2 = 0 ;
16207 int val3 ;
16208 int ecode3 = 0 ;
16209 wxColour temp4 ;
16210 PyObject * obj0 = 0 ;
16211 PyObject * obj1 = 0 ;
16212 PyObject * obj2 = 0 ;
16213 PyObject * obj3 = 0 ;
16214 char * kwnames[] = {
16215 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16216 };
16217
16218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16222 }
16223 arg1 = reinterpret_cast< wxGrid * >(argp1);
16224 ecode2 = SWIG_AsVal_int(obj1, &val2);
16225 if (!SWIG_IsOK(ecode2)) {
16226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16227 }
16228 arg2 = static_cast< int >(val2);
16229 ecode3 = SWIG_AsVal_int(obj2, &val3);
16230 if (!SWIG_IsOK(ecode3)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16232 }
16233 arg3 = static_cast< int >(val3);
16234 {
16235 arg4 = &temp4;
16236 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16237 }
16238 {
16239 PyThreadState* __tstate = wxPyBeginAllowThreads();
16240 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 resultobj = SWIG_Py_Void();
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj = 0;
16253 wxGrid *arg1 = (wxGrid *) 0 ;
16254 wxColour *arg2 = 0 ;
16255 void *argp1 = 0 ;
16256 int res1 = 0 ;
16257 wxColour temp2 ;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 char * kwnames[] = {
16261 (char *) "self",(char *)"arg2", NULL
16262 };
16263
16264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16266 if (!SWIG_IsOK(res1)) {
16267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16268 }
16269 arg1 = reinterpret_cast< wxGrid * >(argp1);
16270 {
16271 arg2 = &temp2;
16272 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16273 }
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_Py_Void();
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxGrid *arg1 = (wxGrid *) 0 ;
16290 int arg2 ;
16291 int arg3 ;
16292 wxColour *arg4 = 0 ;
16293 void *argp1 = 0 ;
16294 int res1 = 0 ;
16295 int val2 ;
16296 int ecode2 = 0 ;
16297 int val3 ;
16298 int ecode3 = 0 ;
16299 wxColour temp4 ;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 PyObject * obj2 = 0 ;
16303 PyObject * obj3 = 0 ;
16304 char * kwnames[] = {
16305 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16306 };
16307
16308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16310 if (!SWIG_IsOK(res1)) {
16311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16312 }
16313 arg1 = reinterpret_cast< wxGrid * >(argp1);
16314 ecode2 = SWIG_AsVal_int(obj1, &val2);
16315 if (!SWIG_IsOK(ecode2)) {
16316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16317 }
16318 arg2 = static_cast< int >(val2);
16319 ecode3 = SWIG_AsVal_int(obj2, &val3);
16320 if (!SWIG_IsOK(ecode3)) {
16321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16322 }
16323 arg3 = static_cast< int >(val3);
16324 {
16325 arg4 = &temp4;
16326 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16327 }
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 resultobj = SWIG_Py_Void();
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj = 0;
16343 wxGrid *arg1 = (wxGrid *) 0 ;
16344 wxFont *arg2 = 0 ;
16345 void *argp1 = 0 ;
16346 int res1 = 0 ;
16347 void *argp2 = 0 ;
16348 int res2 = 0 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 char * kwnames[] = {
16352 (char *) "self",(char *)"arg2", NULL
16353 };
16354
16355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16357 if (!SWIG_IsOK(res1)) {
16358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16359 }
16360 arg1 = reinterpret_cast< wxGrid * >(argp1);
16361 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16362 if (!SWIG_IsOK(res2)) {
16363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16364 }
16365 if (!argp2) {
16366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16367 }
16368 arg2 = reinterpret_cast< wxFont * >(argp2);
16369 {
16370 PyThreadState* __tstate = wxPyBeginAllowThreads();
16371 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16372 wxPyEndAllowThreads(__tstate);
16373 if (PyErr_Occurred()) SWIG_fail;
16374 }
16375 resultobj = SWIG_Py_Void();
16376 return resultobj;
16377 fail:
16378 return NULL;
16379 }
16380
16381
16382 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16383 PyObject *resultobj = 0;
16384 wxGrid *arg1 = (wxGrid *) 0 ;
16385 int arg2 ;
16386 int arg3 ;
16387 wxFont *arg4 = 0 ;
16388 void *argp1 = 0 ;
16389 int res1 = 0 ;
16390 int val2 ;
16391 int ecode2 = 0 ;
16392 int val3 ;
16393 int ecode3 = 0 ;
16394 void *argp4 = 0 ;
16395 int res4 = 0 ;
16396 PyObject * obj0 = 0 ;
16397 PyObject * obj1 = 0 ;
16398 PyObject * obj2 = 0 ;
16399 PyObject * obj3 = 0 ;
16400 char * kwnames[] = {
16401 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16402 };
16403
16404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16408 }
16409 arg1 = reinterpret_cast< wxGrid * >(argp1);
16410 ecode2 = SWIG_AsVal_int(obj1, &val2);
16411 if (!SWIG_IsOK(ecode2)) {
16412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16413 }
16414 arg2 = static_cast< int >(val2);
16415 ecode3 = SWIG_AsVal_int(obj2, &val3);
16416 if (!SWIG_IsOK(ecode3)) {
16417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16418 }
16419 arg3 = static_cast< int >(val3);
16420 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16421 if (!SWIG_IsOK(res4)) {
16422 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16423 }
16424 if (!argp4) {
16425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16426 }
16427 arg4 = reinterpret_cast< wxFont * >(argp4);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_Py_Void();
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj = 0;
16443 wxGrid *arg1 = (wxGrid *) 0 ;
16444 int arg2 ;
16445 int arg3 ;
16446 void *argp1 = 0 ;
16447 int res1 = 0 ;
16448 int val2 ;
16449 int ecode2 = 0 ;
16450 int val3 ;
16451 int ecode3 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 PyObject * obj2 = 0 ;
16455 char * kwnames[] = {
16456 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16457 };
16458
16459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16463 }
16464 arg1 = reinterpret_cast< wxGrid * >(argp1);
16465 ecode2 = SWIG_AsVal_int(obj1, &val2);
16466 if (!SWIG_IsOK(ecode2)) {
16467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16468 }
16469 arg2 = static_cast< int >(val2);
16470 ecode3 = SWIG_AsVal_int(obj2, &val3);
16471 if (!SWIG_IsOK(ecode3)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16473 }
16474 arg3 = static_cast< int >(val3);
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 resultobj = SWIG_Py_Void();
16482 return resultobj;
16483 fail:
16484 return NULL;
16485 }
16486
16487
16488 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj = 0;
16490 wxGrid *arg1 = (wxGrid *) 0 ;
16491 int arg2 ;
16492 int arg3 ;
16493 int arg4 ;
16494 int arg5 ;
16495 void *argp1 = 0 ;
16496 int res1 = 0 ;
16497 int val2 ;
16498 int ecode2 = 0 ;
16499 int val3 ;
16500 int ecode3 = 0 ;
16501 int val4 ;
16502 int ecode4 = 0 ;
16503 int val5 ;
16504 int ecode5 = 0 ;
16505 PyObject * obj0 = 0 ;
16506 PyObject * obj1 = 0 ;
16507 PyObject * obj2 = 0 ;
16508 PyObject * obj3 = 0 ;
16509 PyObject * obj4 = 0 ;
16510 char * kwnames[] = {
16511 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16512 };
16513
16514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16516 if (!SWIG_IsOK(res1)) {
16517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16518 }
16519 arg1 = reinterpret_cast< wxGrid * >(argp1);
16520 ecode2 = SWIG_AsVal_int(obj1, &val2);
16521 if (!SWIG_IsOK(ecode2)) {
16522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16523 }
16524 arg2 = static_cast< int >(val2);
16525 ecode3 = SWIG_AsVal_int(obj2, &val3);
16526 if (!SWIG_IsOK(ecode3)) {
16527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16528 }
16529 arg3 = static_cast< int >(val3);
16530 ecode4 = SWIG_AsVal_int(obj3, &val4);
16531 if (!SWIG_IsOK(ecode4)) {
16532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16533 }
16534 arg4 = static_cast< int >(val4);
16535 ecode5 = SWIG_AsVal_int(obj4, &val5);
16536 if (!SWIG_IsOK(ecode5)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16538 }
16539 arg5 = static_cast< int >(val5);
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 resultobj = SWIG_Py_Void();
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj = 0;
16555 wxGrid *arg1 = (wxGrid *) 0 ;
16556 bool arg2 ;
16557 void *argp1 = 0 ;
16558 int res1 = 0 ;
16559 bool val2 ;
16560 int ecode2 = 0 ;
16561 PyObject * obj0 = 0 ;
16562 PyObject * obj1 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "self",(char *) "allow", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16571 }
16572 arg1 = reinterpret_cast< wxGrid * >(argp1);
16573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16574 if (!SWIG_IsOK(ecode2)) {
16575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16576 }
16577 arg2 = static_cast< bool >(val2);
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 (arg1)->SetDefaultCellOverflow(arg2);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 resultobj = SWIG_Py_Void();
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj = 0;
16593 wxGrid *arg1 = (wxGrid *) 0 ;
16594 int arg2 ;
16595 int arg3 ;
16596 bool arg4 ;
16597 void *argp1 = 0 ;
16598 int res1 = 0 ;
16599 int val2 ;
16600 int ecode2 = 0 ;
16601 int val3 ;
16602 int ecode3 = 0 ;
16603 bool val4 ;
16604 int ecode4 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 char * kwnames[] = {
16610 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16611 };
16612
16613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16617 }
16618 arg1 = reinterpret_cast< wxGrid * >(argp1);
16619 ecode2 = SWIG_AsVal_int(obj1, &val2);
16620 if (!SWIG_IsOK(ecode2)) {
16621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16622 }
16623 arg2 = static_cast< int >(val2);
16624 ecode3 = SWIG_AsVal_int(obj2, &val3);
16625 if (!SWIG_IsOK(ecode3)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16627 }
16628 arg3 = static_cast< int >(val3);
16629 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16630 if (!SWIG_IsOK(ecode4)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16632 }
16633 arg4 = static_cast< bool >(val4);
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_Py_Void();
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxGrid *arg1 = (wxGrid *) 0 ;
16650 int arg2 ;
16651 int arg3 ;
16652 int arg4 ;
16653 int arg5 ;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 int val2 ;
16657 int ecode2 = 0 ;
16658 int val3 ;
16659 int ecode3 = 0 ;
16660 int val4 ;
16661 int ecode4 = 0 ;
16662 int val5 ;
16663 int ecode5 = 0 ;
16664 PyObject * obj0 = 0 ;
16665 PyObject * obj1 = 0 ;
16666 PyObject * obj2 = 0 ;
16667 PyObject * obj3 = 0 ;
16668 PyObject * obj4 = 0 ;
16669 char * kwnames[] = {
16670 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16671 };
16672
16673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16675 if (!SWIG_IsOK(res1)) {
16676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16677 }
16678 arg1 = reinterpret_cast< wxGrid * >(argp1);
16679 ecode2 = SWIG_AsVal_int(obj1, &val2);
16680 if (!SWIG_IsOK(ecode2)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16682 }
16683 arg2 = static_cast< int >(val2);
16684 ecode3 = SWIG_AsVal_int(obj2, &val3);
16685 if (!SWIG_IsOK(ecode3)) {
16686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16687 }
16688 arg3 = static_cast< int >(val3);
16689 ecode4 = SWIG_AsVal_int(obj3, &val4);
16690 if (!SWIG_IsOK(ecode4)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16692 }
16693 arg4 = static_cast< int >(val4);
16694 ecode5 = SWIG_AsVal_int(obj4, &val5);
16695 if (!SWIG_IsOK(ecode5)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16697 }
16698 arg5 = static_cast< int >(val5);
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16702 wxPyEndAllowThreads(__tstate);
16703 if (PyErr_Occurred()) SWIG_fail;
16704 }
16705 resultobj = SWIG_Py_Void();
16706 return resultobj;
16707 fail:
16708 return NULL;
16709 }
16710
16711
16712 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16713 PyObject *resultobj = 0;
16714 wxGrid *arg1 = (wxGrid *) 0 ;
16715 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16716 void *argp1 = 0 ;
16717 int res1 = 0 ;
16718 void *argp2 = 0 ;
16719 int res2 = 0 ;
16720 PyObject * obj0 = 0 ;
16721 PyObject * obj1 = 0 ;
16722 char * kwnames[] = {
16723 (char *) "self",(char *) "renderer", NULL
16724 };
16725
16726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16730 }
16731 arg1 = reinterpret_cast< wxGrid * >(argp1);
16732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16733 if (!SWIG_IsOK(res2)) {
16734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16735 }
16736 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 (arg1)->SetDefaultRenderer(arg2);
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 resultobj = SWIG_Py_Void();
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj = 0;
16752 wxGrid *arg1 = (wxGrid *) 0 ;
16753 int arg2 ;
16754 int arg3 ;
16755 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16756 void *argp1 = 0 ;
16757 int res1 = 0 ;
16758 int val2 ;
16759 int ecode2 = 0 ;
16760 int val3 ;
16761 int ecode3 = 0 ;
16762 void *argp4 = 0 ;
16763 int res4 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 PyObject * obj2 = 0 ;
16767 PyObject * obj3 = 0 ;
16768 char * kwnames[] = {
16769 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16770 };
16771
16772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16774 if (!SWIG_IsOK(res1)) {
16775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16776 }
16777 arg1 = reinterpret_cast< wxGrid * >(argp1);
16778 ecode2 = SWIG_AsVal_int(obj1, &val2);
16779 if (!SWIG_IsOK(ecode2)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16781 }
16782 arg2 = static_cast< int >(val2);
16783 ecode3 = SWIG_AsVal_int(obj2, &val3);
16784 if (!SWIG_IsOK(ecode3)) {
16785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16786 }
16787 arg3 = static_cast< int >(val3);
16788 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16789 if (!SWIG_IsOK(res4)) {
16790 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16791 }
16792 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_Py_Void();
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16807 PyObject *resultobj = 0;
16808 wxGrid *arg1 = (wxGrid *) 0 ;
16809 wxGridCellRenderer *result = 0 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 PyObject *swig_obj[1] ;
16813
16814 if (!args) SWIG_fail;
16815 swig_obj[0] = args;
16816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16819 }
16820 arg1 = reinterpret_cast< wxGrid * >(argp1);
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxGrid *arg1 = (wxGrid *) 0 ;
16839 int arg2 ;
16840 int arg3 ;
16841 wxGridCellRenderer *result = 0 ;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 int val2 ;
16845 int ecode2 = 0 ;
16846 int val3 ;
16847 int ecode3 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 PyObject * obj2 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "self",(char *) "row",(char *) "col", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16859 }
16860 arg1 = reinterpret_cast< wxGrid * >(argp1);
16861 ecode2 = SWIG_AsVal_int(obj1, &val2);
16862 if (!SWIG_IsOK(ecode2)) {
16863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16864 }
16865 arg2 = static_cast< int >(val2);
16866 ecode3 = SWIG_AsVal_int(obj2, &val3);
16867 if (!SWIG_IsOK(ecode3)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16869 }
16870 arg3 = static_cast< int >(val3);
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16879 }
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16887 PyObject *resultobj = 0;
16888 wxGrid *arg1 = (wxGrid *) 0 ;
16889 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16890 void *argp1 = 0 ;
16891 int res1 = 0 ;
16892 void *argp2 = 0 ;
16893 int res2 = 0 ;
16894 PyObject * obj0 = 0 ;
16895 PyObject * obj1 = 0 ;
16896 char * kwnames[] = {
16897 (char *) "self",(char *) "editor", NULL
16898 };
16899
16900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16902 if (!SWIG_IsOK(res1)) {
16903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16904 }
16905 arg1 = reinterpret_cast< wxGrid * >(argp1);
16906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16907 if (!SWIG_IsOK(res2)) {
16908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16909 }
16910 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 (arg1)->SetDefaultEditor(arg2);
16914 wxPyEndAllowThreads(__tstate);
16915 if (PyErr_Occurred()) SWIG_fail;
16916 }
16917 resultobj = SWIG_Py_Void();
16918 return resultobj;
16919 fail:
16920 return NULL;
16921 }
16922
16923
16924 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16925 PyObject *resultobj = 0;
16926 wxGrid *arg1 = (wxGrid *) 0 ;
16927 int arg2 ;
16928 int arg3 ;
16929 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 int val2 ;
16933 int ecode2 = 0 ;
16934 int val3 ;
16935 int ecode3 = 0 ;
16936 void *argp4 = 0 ;
16937 int res4 = 0 ;
16938 PyObject * obj0 = 0 ;
16939 PyObject * obj1 = 0 ;
16940 PyObject * obj2 = 0 ;
16941 PyObject * obj3 = 0 ;
16942 char * kwnames[] = {
16943 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16944 };
16945
16946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16950 }
16951 arg1 = reinterpret_cast< wxGrid * >(argp1);
16952 ecode2 = SWIG_AsVal_int(obj1, &val2);
16953 if (!SWIG_IsOK(ecode2)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16955 }
16956 arg2 = static_cast< int >(val2);
16957 ecode3 = SWIG_AsVal_int(obj2, &val3);
16958 if (!SWIG_IsOK(ecode3)) {
16959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16960 }
16961 arg3 = static_cast< int >(val3);
16962 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16963 if (!SWIG_IsOK(res4)) {
16964 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16965 }
16966 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16967 {
16968 PyThreadState* __tstate = wxPyBeginAllowThreads();
16969 (arg1)->SetCellEditor(arg2,arg3,arg4);
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 resultobj = SWIG_Py_Void();
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16981 PyObject *resultobj = 0;
16982 wxGrid *arg1 = (wxGrid *) 0 ;
16983 wxGridCellEditor *result = 0 ;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 PyObject *swig_obj[1] ;
16987
16988 if (!args) SWIG_fail;
16989 swig_obj[0] = args;
16990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16993 }
16994 arg1 = reinterpret_cast< wxGrid * >(argp1);
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 {
17002 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17003 }
17004 return resultobj;
17005 fail:
17006 return NULL;
17007 }
17008
17009
17010 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17011 PyObject *resultobj = 0;
17012 wxGrid *arg1 = (wxGrid *) 0 ;
17013 int arg2 ;
17014 int arg3 ;
17015 wxGridCellEditor *result = 0 ;
17016 void *argp1 = 0 ;
17017 int res1 = 0 ;
17018 int val2 ;
17019 int ecode2 = 0 ;
17020 int val3 ;
17021 int ecode3 = 0 ;
17022 PyObject * obj0 = 0 ;
17023 PyObject * obj1 = 0 ;
17024 PyObject * obj2 = 0 ;
17025 char * kwnames[] = {
17026 (char *) "self",(char *) "row",(char *) "col", NULL
17027 };
17028
17029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17031 if (!SWIG_IsOK(res1)) {
17032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17033 }
17034 arg1 = reinterpret_cast< wxGrid * >(argp1);
17035 ecode2 = SWIG_AsVal_int(obj1, &val2);
17036 if (!SWIG_IsOK(ecode2)) {
17037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17038 }
17039 arg2 = static_cast< int >(val2);
17040 ecode3 = SWIG_AsVal_int(obj2, &val3);
17041 if (!SWIG_IsOK(ecode3)) {
17042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17043 }
17044 arg3 = static_cast< int >(val3);
17045 {
17046 PyThreadState* __tstate = wxPyBeginAllowThreads();
17047 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17048 wxPyEndAllowThreads(__tstate);
17049 if (PyErr_Occurred()) SWIG_fail;
17050 }
17051 {
17052 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17053 }
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj = 0;
17062 wxGrid *arg1 = (wxGrid *) 0 ;
17063 int arg2 ;
17064 int arg3 ;
17065 wxString result;
17066 void *argp1 = 0 ;
17067 int res1 = 0 ;
17068 int val2 ;
17069 int ecode2 = 0 ;
17070 int val3 ;
17071 int ecode3 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 PyObject * obj1 = 0 ;
17074 PyObject * obj2 = 0 ;
17075 char * kwnames[] = {
17076 (char *) "self",(char *) "row",(char *) "col", NULL
17077 };
17078
17079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17081 if (!SWIG_IsOK(res1)) {
17082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17083 }
17084 arg1 = reinterpret_cast< wxGrid * >(argp1);
17085 ecode2 = SWIG_AsVal_int(obj1, &val2);
17086 if (!SWIG_IsOK(ecode2)) {
17087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17088 }
17089 arg2 = static_cast< int >(val2);
17090 ecode3 = SWIG_AsVal_int(obj2, &val3);
17091 if (!SWIG_IsOK(ecode3)) {
17092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17093 }
17094 arg3 = static_cast< int >(val3);
17095 {
17096 PyThreadState* __tstate = wxPyBeginAllowThreads();
17097 result = (arg1)->GetCellValue(arg2,arg3);
17098 wxPyEndAllowThreads(__tstate);
17099 if (PyErr_Occurred()) SWIG_fail;
17100 }
17101 {
17102 #if wxUSE_UNICODE
17103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17104 #else
17105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17106 #endif
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj = 0;
17116 wxGrid *arg1 = (wxGrid *) 0 ;
17117 int arg2 ;
17118 int arg3 ;
17119 wxString *arg4 = 0 ;
17120 void *argp1 = 0 ;
17121 int res1 = 0 ;
17122 int val2 ;
17123 int ecode2 = 0 ;
17124 int val3 ;
17125 int ecode3 = 0 ;
17126 bool temp4 = false ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 PyObject * obj2 = 0 ;
17130 PyObject * obj3 = 0 ;
17131 char * kwnames[] = {
17132 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17133 };
17134
17135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17137 if (!SWIG_IsOK(res1)) {
17138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17139 }
17140 arg1 = reinterpret_cast< wxGrid * >(argp1);
17141 ecode2 = SWIG_AsVal_int(obj1, &val2);
17142 if (!SWIG_IsOK(ecode2)) {
17143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17144 }
17145 arg2 = static_cast< int >(val2);
17146 ecode3 = SWIG_AsVal_int(obj2, &val3);
17147 if (!SWIG_IsOK(ecode3)) {
17148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17149 }
17150 arg3 = static_cast< int >(val3);
17151 {
17152 arg4 = wxString_in_helper(obj3);
17153 if (arg4 == NULL) SWIG_fail;
17154 temp4 = true;
17155 }
17156 {
17157 PyThreadState* __tstate = wxPyBeginAllowThreads();
17158 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17159 wxPyEndAllowThreads(__tstate);
17160 if (PyErr_Occurred()) SWIG_fail;
17161 }
17162 resultobj = SWIG_Py_Void();
17163 {
17164 if (temp4)
17165 delete arg4;
17166 }
17167 return resultobj;
17168 fail:
17169 {
17170 if (temp4)
17171 delete arg4;
17172 }
17173 return NULL;
17174 }
17175
17176
17177 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj = 0;
17179 wxGrid *arg1 = (wxGrid *) 0 ;
17180 int arg2 ;
17181 int arg3 ;
17182 bool result;
17183 void *argp1 = 0 ;
17184 int res1 = 0 ;
17185 int val2 ;
17186 int ecode2 = 0 ;
17187 int val3 ;
17188 int ecode3 = 0 ;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 PyObject * obj2 = 0 ;
17192 char * kwnames[] = {
17193 (char *) "self",(char *) "row",(char *) "col", NULL
17194 };
17195
17196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17198 if (!SWIG_IsOK(res1)) {
17199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17200 }
17201 arg1 = reinterpret_cast< wxGrid * >(argp1);
17202 ecode2 = SWIG_AsVal_int(obj1, &val2);
17203 if (!SWIG_IsOK(ecode2)) {
17204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17205 }
17206 arg2 = static_cast< int >(val2);
17207 ecode3 = SWIG_AsVal_int(obj2, &val3);
17208 if (!SWIG_IsOK(ecode3)) {
17209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17210 }
17211 arg3 = static_cast< int >(val3);
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 {
17219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = 0;
17229 wxGrid *arg1 = (wxGrid *) 0 ;
17230 int arg2 ;
17231 int arg3 ;
17232 bool arg4 = (bool) true ;
17233 void *argp1 = 0 ;
17234 int res1 = 0 ;
17235 int val2 ;
17236 int ecode2 = 0 ;
17237 int val3 ;
17238 int ecode3 = 0 ;
17239 bool val4 ;
17240 int ecode4 = 0 ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 PyObject * obj2 = 0 ;
17244 PyObject * obj3 = 0 ;
17245 char * kwnames[] = {
17246 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17247 };
17248
17249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17251 if (!SWIG_IsOK(res1)) {
17252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17253 }
17254 arg1 = reinterpret_cast< wxGrid * >(argp1);
17255 ecode2 = SWIG_AsVal_int(obj1, &val2);
17256 if (!SWIG_IsOK(ecode2)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17258 }
17259 arg2 = static_cast< int >(val2);
17260 ecode3 = SWIG_AsVal_int(obj2, &val3);
17261 if (!SWIG_IsOK(ecode3)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17263 }
17264 arg3 = static_cast< int >(val3);
17265 if (obj3) {
17266 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17267 if (!SWIG_IsOK(ecode4)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17269 }
17270 arg4 = static_cast< bool >(val4);
17271 }
17272 {
17273 PyThreadState* __tstate = wxPyBeginAllowThreads();
17274 (arg1)->SetReadOnly(arg2,arg3,arg4);
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = SWIG_Py_Void();
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxGrid *arg1 = (wxGrid *) 0 ;
17288 int arg2 ;
17289 bool arg3 = (bool) false ;
17290 void *argp1 = 0 ;
17291 int res1 = 0 ;
17292 int val2 ;
17293 int ecode2 = 0 ;
17294 bool val3 ;
17295 int ecode3 = 0 ;
17296 PyObject * obj0 = 0 ;
17297 PyObject * obj1 = 0 ;
17298 PyObject * obj2 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17305 if (!SWIG_IsOK(res1)) {
17306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17307 }
17308 arg1 = reinterpret_cast< wxGrid * >(argp1);
17309 ecode2 = SWIG_AsVal_int(obj1, &val2);
17310 if (!SWIG_IsOK(ecode2)) {
17311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17312 }
17313 arg2 = static_cast< int >(val2);
17314 if (obj2) {
17315 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17316 if (!SWIG_IsOK(ecode3)) {
17317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17318 }
17319 arg3 = static_cast< bool >(val3);
17320 }
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 (arg1)->SelectRow(arg2,arg3);
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 resultobj = SWIG_Py_Void();
17328 return resultobj;
17329 fail:
17330 return NULL;
17331 }
17332
17333
17334 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17335 PyObject *resultobj = 0;
17336 wxGrid *arg1 = (wxGrid *) 0 ;
17337 int arg2 ;
17338 bool arg3 = (bool) false ;
17339 void *argp1 = 0 ;
17340 int res1 = 0 ;
17341 int val2 ;
17342 int ecode2 = 0 ;
17343 bool val3 ;
17344 int ecode3 = 0 ;
17345 PyObject * obj0 = 0 ;
17346 PyObject * obj1 = 0 ;
17347 PyObject * obj2 = 0 ;
17348 char * kwnames[] = {
17349 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17350 };
17351
17352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17354 if (!SWIG_IsOK(res1)) {
17355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17356 }
17357 arg1 = reinterpret_cast< wxGrid * >(argp1);
17358 ecode2 = SWIG_AsVal_int(obj1, &val2);
17359 if (!SWIG_IsOK(ecode2)) {
17360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17361 }
17362 arg2 = static_cast< int >(val2);
17363 if (obj2) {
17364 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17365 if (!SWIG_IsOK(ecode3)) {
17366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17367 }
17368 arg3 = static_cast< bool >(val3);
17369 }
17370 {
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 (arg1)->SelectCol(arg2,arg3);
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 resultobj = SWIG_Py_Void();
17377 return resultobj;
17378 fail:
17379 return NULL;
17380 }
17381
17382
17383 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17384 PyObject *resultobj = 0;
17385 wxGrid *arg1 = (wxGrid *) 0 ;
17386 int arg2 ;
17387 int arg3 ;
17388 int arg4 ;
17389 int arg5 ;
17390 bool arg6 = (bool) false ;
17391 void *argp1 = 0 ;
17392 int res1 = 0 ;
17393 int val2 ;
17394 int ecode2 = 0 ;
17395 int val3 ;
17396 int ecode3 = 0 ;
17397 int val4 ;
17398 int ecode4 = 0 ;
17399 int val5 ;
17400 int ecode5 = 0 ;
17401 bool val6 ;
17402 int ecode6 = 0 ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 PyObject * obj2 = 0 ;
17406 PyObject * obj3 = 0 ;
17407 PyObject * obj4 = 0 ;
17408 PyObject * obj5 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17415 if (!SWIG_IsOK(res1)) {
17416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17417 }
17418 arg1 = reinterpret_cast< wxGrid * >(argp1);
17419 ecode2 = SWIG_AsVal_int(obj1, &val2);
17420 if (!SWIG_IsOK(ecode2)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17422 }
17423 arg2 = static_cast< int >(val2);
17424 ecode3 = SWIG_AsVal_int(obj2, &val3);
17425 if (!SWIG_IsOK(ecode3)) {
17426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17427 }
17428 arg3 = static_cast< int >(val3);
17429 ecode4 = SWIG_AsVal_int(obj3, &val4);
17430 if (!SWIG_IsOK(ecode4)) {
17431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17432 }
17433 arg4 = static_cast< int >(val4);
17434 ecode5 = SWIG_AsVal_int(obj4, &val5);
17435 if (!SWIG_IsOK(ecode5)) {
17436 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17437 }
17438 arg5 = static_cast< int >(val5);
17439 if (obj5) {
17440 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17441 if (!SWIG_IsOK(ecode6)) {
17442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17443 }
17444 arg6 = static_cast< bool >(val6);
17445 }
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_Py_Void();
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *resultobj = 0;
17461 wxGrid *arg1 = (wxGrid *) 0 ;
17462 void *argp1 = 0 ;
17463 int res1 = 0 ;
17464 PyObject *swig_obj[1] ;
17465
17466 if (!args) SWIG_fail;
17467 swig_obj[0] = args;
17468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17469 if (!SWIG_IsOK(res1)) {
17470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17471 }
17472 arg1 = reinterpret_cast< wxGrid * >(argp1);
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 (arg1)->SelectAll();
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_Py_Void();
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *resultobj = 0;
17488 wxGrid *arg1 = (wxGrid *) 0 ;
17489 bool result;
17490 void *argp1 = 0 ;
17491 int res1 = 0 ;
17492 PyObject *swig_obj[1] ;
17493
17494 if (!args) SWIG_fail;
17495 swig_obj[0] = args;
17496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17497 if (!SWIG_IsOK(res1)) {
17498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17499 }
17500 arg1 = reinterpret_cast< wxGrid * >(argp1);
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (bool)(arg1)->IsSelection();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 {
17508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17509 }
17510 return resultobj;
17511 fail:
17512 return NULL;
17513 }
17514
17515
17516 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 PyObject *resultobj = 0;
17518 wxGrid *arg1 = (wxGrid *) 0 ;
17519 void *argp1 = 0 ;
17520 int res1 = 0 ;
17521 PyObject *swig_obj[1] ;
17522
17523 if (!args) SWIG_fail;
17524 swig_obj[0] = args;
17525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17526 if (!SWIG_IsOK(res1)) {
17527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17528 }
17529 arg1 = reinterpret_cast< wxGrid * >(argp1);
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 (arg1)->ClearSelection();
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_Py_Void();
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17544 PyObject *resultobj = 0;
17545 wxGrid *arg1 = (wxGrid *) 0 ;
17546 int arg2 ;
17547 int arg3 ;
17548 bool result;
17549 void *argp1 = 0 ;
17550 int res1 = 0 ;
17551 int val2 ;
17552 int ecode2 = 0 ;
17553 int val3 ;
17554 int ecode3 = 0 ;
17555 PyObject * obj0 = 0 ;
17556 PyObject * obj1 = 0 ;
17557 PyObject * obj2 = 0 ;
17558 char * kwnames[] = {
17559 (char *) "self",(char *) "row",(char *) "col", NULL
17560 };
17561
17562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17564 if (!SWIG_IsOK(res1)) {
17565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17566 }
17567 arg1 = reinterpret_cast< wxGrid * >(argp1);
17568 ecode2 = SWIG_AsVal_int(obj1, &val2);
17569 if (!SWIG_IsOK(ecode2)) {
17570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17571 }
17572 arg2 = static_cast< int >(val2);
17573 ecode3 = SWIG_AsVal_int(obj2, &val3);
17574 if (!SWIG_IsOK(ecode3)) {
17575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17576 }
17577 arg3 = static_cast< int >(val3);
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17594 PyObject *resultobj = 0;
17595 wxGrid *arg1 = (wxGrid *) 0 ;
17596 wxGridCellCoordsArray result;
17597 void *argp1 = 0 ;
17598 int res1 = 0 ;
17599 PyObject *swig_obj[1] ;
17600
17601 if (!args) SWIG_fail;
17602 swig_obj[0] = args;
17603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17604 if (!SWIG_IsOK(res1)) {
17605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17606 }
17607 arg1 = reinterpret_cast< wxGrid * >(argp1);
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = ((wxGrid const *)arg1)->GetSelectedCells();
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = wxGridCellCoordsArray_helper(result);
17616 }
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *resultobj = 0;
17625 wxGrid *arg1 = (wxGrid *) 0 ;
17626 wxGridCellCoordsArray result;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 PyObject *swig_obj[1] ;
17630
17631 if (!args) SWIG_fail;
17632 swig_obj[0] = args;
17633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17636 }
17637 arg1 = reinterpret_cast< wxGrid * >(argp1);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = wxGridCellCoordsArray_helper(result);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 PyObject *resultobj = 0;
17655 wxGrid *arg1 = (wxGrid *) 0 ;
17656 wxGridCellCoordsArray result;
17657 void *argp1 = 0 ;
17658 int res1 = 0 ;
17659 PyObject *swig_obj[1] ;
17660
17661 if (!args) SWIG_fail;
17662 swig_obj[0] = args;
17663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17664 if (!SWIG_IsOK(res1)) {
17665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17666 }
17667 arg1 = reinterpret_cast< wxGrid * >(argp1);
17668 {
17669 PyThreadState* __tstate = wxPyBeginAllowThreads();
17670 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 {
17675 resultobj = wxGridCellCoordsArray_helper(result);
17676 }
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17684 PyObject *resultobj = 0;
17685 wxGrid *arg1 = (wxGrid *) 0 ;
17686 wxArrayInt result;
17687 void *argp1 = 0 ;
17688 int res1 = 0 ;
17689 PyObject *swig_obj[1] ;
17690
17691 if (!args) SWIG_fail;
17692 swig_obj[0] = args;
17693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17694 if (!SWIG_IsOK(res1)) {
17695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17696 }
17697 arg1 = reinterpret_cast< wxGrid * >(argp1);
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = ((wxGrid const *)arg1)->GetSelectedRows();
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 {
17705 resultobj = PyList_New(0);
17706 size_t idx;
17707 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17708 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17709 PyList_Append(resultobj, val);
17710 Py_DECREF(val);
17711 }
17712 }
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17720 PyObject *resultobj = 0;
17721 wxGrid *arg1 = (wxGrid *) 0 ;
17722 wxArrayInt result;
17723 void *argp1 = 0 ;
17724 int res1 = 0 ;
17725 PyObject *swig_obj[1] ;
17726
17727 if (!args) SWIG_fail;
17728 swig_obj[0] = args;
17729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17730 if (!SWIG_IsOK(res1)) {
17731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17732 }
17733 arg1 = reinterpret_cast< wxGrid * >(argp1);
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = ((wxGrid const *)arg1)->GetSelectedCols();
17737 wxPyEndAllowThreads(__tstate);
17738 if (PyErr_Occurred()) SWIG_fail;
17739 }
17740 {
17741 resultobj = PyList_New(0);
17742 size_t idx;
17743 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17744 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17745 PyList_Append(resultobj, val);
17746 Py_DECREF(val);
17747 }
17748 }
17749 return resultobj;
17750 fail:
17751 return NULL;
17752 }
17753
17754
17755 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17756 PyObject *resultobj = 0;
17757 wxGrid *arg1 = (wxGrid *) 0 ;
17758 int arg2 ;
17759 void *argp1 = 0 ;
17760 int res1 = 0 ;
17761 int val2 ;
17762 int ecode2 = 0 ;
17763 PyObject * obj0 = 0 ;
17764 PyObject * obj1 = 0 ;
17765 char * kwnames[] = {
17766 (char *) "self",(char *) "row", NULL
17767 };
17768
17769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17771 if (!SWIG_IsOK(res1)) {
17772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17773 }
17774 arg1 = reinterpret_cast< wxGrid * >(argp1);
17775 ecode2 = SWIG_AsVal_int(obj1, &val2);
17776 if (!SWIG_IsOK(ecode2)) {
17777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17778 }
17779 arg2 = static_cast< int >(val2);
17780 {
17781 PyThreadState* __tstate = wxPyBeginAllowThreads();
17782 (arg1)->DeselectRow(arg2);
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 resultobj = SWIG_Py_Void();
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj = 0;
17795 wxGrid *arg1 = (wxGrid *) 0 ;
17796 int arg2 ;
17797 void *argp1 = 0 ;
17798 int res1 = 0 ;
17799 int val2 ;
17800 int ecode2 = 0 ;
17801 PyObject * obj0 = 0 ;
17802 PyObject * obj1 = 0 ;
17803 char * kwnames[] = {
17804 (char *) "self",(char *) "col", NULL
17805 };
17806
17807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17809 if (!SWIG_IsOK(res1)) {
17810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17811 }
17812 arg1 = reinterpret_cast< wxGrid * >(argp1);
17813 ecode2 = SWIG_AsVal_int(obj1, &val2);
17814 if (!SWIG_IsOK(ecode2)) {
17815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17816 }
17817 arg2 = static_cast< int >(val2);
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 (arg1)->DeselectCol(arg2);
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 resultobj = SWIG_Py_Void();
17825 return resultobj;
17826 fail:
17827 return NULL;
17828 }
17829
17830
17831 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17832 PyObject *resultobj = 0;
17833 wxGrid *arg1 = (wxGrid *) 0 ;
17834 int arg2 ;
17835 int arg3 ;
17836 void *argp1 = 0 ;
17837 int res1 = 0 ;
17838 int val2 ;
17839 int ecode2 = 0 ;
17840 int val3 ;
17841 int ecode3 = 0 ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 PyObject * obj2 = 0 ;
17845 char * kwnames[] = {
17846 (char *) "self",(char *) "row",(char *) "col", NULL
17847 };
17848
17849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17851 if (!SWIG_IsOK(res1)) {
17852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17853 }
17854 arg1 = reinterpret_cast< wxGrid * >(argp1);
17855 ecode2 = SWIG_AsVal_int(obj1, &val2);
17856 if (!SWIG_IsOK(ecode2)) {
17857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17858 }
17859 arg2 = static_cast< int >(val2);
17860 ecode3 = SWIG_AsVal_int(obj2, &val3);
17861 if (!SWIG_IsOK(ecode3)) {
17862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17863 }
17864 arg3 = static_cast< int >(val3);
17865 {
17866 PyThreadState* __tstate = wxPyBeginAllowThreads();
17867 (arg1)->DeselectCell(arg2,arg3);
17868 wxPyEndAllowThreads(__tstate);
17869 if (PyErr_Occurred()) SWIG_fail;
17870 }
17871 resultobj = SWIG_Py_Void();
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17879 PyObject *resultobj = 0;
17880 wxGrid *arg1 = (wxGrid *) 0 ;
17881 wxGridCellCoords *arg2 = 0 ;
17882 wxGridCellCoords *arg3 = 0 ;
17883 wxRect result;
17884 void *argp1 = 0 ;
17885 int res1 = 0 ;
17886 wxGridCellCoords temp2 ;
17887 wxGridCellCoords temp3 ;
17888 PyObject * obj0 = 0 ;
17889 PyObject * obj1 = 0 ;
17890 PyObject * obj2 = 0 ;
17891 char * kwnames[] = {
17892 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17893 };
17894
17895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17897 if (!SWIG_IsOK(res1)) {
17898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17899 }
17900 arg1 = reinterpret_cast< wxGrid * >(argp1);
17901 {
17902 arg2 = &temp2;
17903 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17904 }
17905 {
17906 arg3 = &temp3;
17907 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17908 }
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17916 return resultobj;
17917 fail:
17918 return NULL;
17919 }
17920
17921
17922 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17923 PyObject *resultobj = 0;
17924 wxGrid *arg1 = (wxGrid *) 0 ;
17925 wxColour result;
17926 void *argp1 = 0 ;
17927 int res1 = 0 ;
17928 PyObject *swig_obj[1] ;
17929
17930 if (!args) SWIG_fail;
17931 swig_obj[0] = args;
17932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17933 if (!SWIG_IsOK(res1)) {
17934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17935 }
17936 arg1 = reinterpret_cast< wxGrid * >(argp1);
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17944 return resultobj;
17945 fail:
17946 return NULL;
17947 }
17948
17949
17950 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17951 PyObject *resultobj = 0;
17952 wxGrid *arg1 = (wxGrid *) 0 ;
17953 wxColour result;
17954 void *argp1 = 0 ;
17955 int res1 = 0 ;
17956 PyObject *swig_obj[1] ;
17957
17958 if (!args) SWIG_fail;
17959 swig_obj[0] = args;
17960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17961 if (!SWIG_IsOK(res1)) {
17962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17963 }
17964 arg1 = reinterpret_cast< wxGrid * >(argp1);
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj = 0;
17980 wxGrid *arg1 = (wxGrid *) 0 ;
17981 wxColour *arg2 = 0 ;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 wxColour temp2 ;
17985 PyObject * obj0 = 0 ;
17986 PyObject * obj1 = 0 ;
17987 char * kwnames[] = {
17988 (char *) "self",(char *) "c", NULL
17989 };
17990
17991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17993 if (!SWIG_IsOK(res1)) {
17994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
17995 }
17996 arg1 = reinterpret_cast< wxGrid * >(argp1);
17997 {
17998 arg2 = &temp2;
17999 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18000 }
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 resultobj = SWIG_Py_Void();
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj = 0;
18016 wxGrid *arg1 = (wxGrid *) 0 ;
18017 wxColour *arg2 = 0 ;
18018 void *argp1 = 0 ;
18019 int res1 = 0 ;
18020 wxColour temp2 ;
18021 PyObject * obj0 = 0 ;
18022 PyObject * obj1 = 0 ;
18023 char * kwnames[] = {
18024 (char *) "self",(char *) "c", NULL
18025 };
18026
18027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18031 }
18032 arg1 = reinterpret_cast< wxGrid * >(argp1);
18033 {
18034 arg2 = &temp2;
18035 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18036 }
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = SWIG_Py_Void();
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18051 PyObject *resultobj = 0;
18052 wxGrid *arg1 = (wxGrid *) 0 ;
18053 wxString *arg2 = 0 ;
18054 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18055 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18056 void *argp1 = 0 ;
18057 int res1 = 0 ;
18058 bool temp2 = false ;
18059 void *argp3 = 0 ;
18060 int res3 = 0 ;
18061 void *argp4 = 0 ;
18062 int res4 = 0 ;
18063 PyObject * obj0 = 0 ;
18064 PyObject * obj1 = 0 ;
18065 PyObject * obj2 = 0 ;
18066 PyObject * obj3 = 0 ;
18067 char * kwnames[] = {
18068 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18069 };
18070
18071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18075 }
18076 arg1 = reinterpret_cast< wxGrid * >(argp1);
18077 {
18078 arg2 = wxString_in_helper(obj1);
18079 if (arg2 == NULL) SWIG_fail;
18080 temp2 = true;
18081 }
18082 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18083 if (!SWIG_IsOK(res3)) {
18084 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18085 }
18086 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18087 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18088 if (!SWIG_IsOK(res4)) {
18089 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18090 }
18091 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 resultobj = SWIG_Py_Void();
18099 {
18100 if (temp2)
18101 delete arg2;
18102 }
18103 return resultobj;
18104 fail:
18105 {
18106 if (temp2)
18107 delete arg2;
18108 }
18109 return NULL;
18110 }
18111
18112
18113 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj = 0;
18115 wxGrid *arg1 = (wxGrid *) 0 ;
18116 int arg2 ;
18117 int arg3 ;
18118 wxGridCellEditor *result = 0 ;
18119 void *argp1 = 0 ;
18120 int res1 = 0 ;
18121 int val2 ;
18122 int ecode2 = 0 ;
18123 int val3 ;
18124 int ecode3 = 0 ;
18125 PyObject * obj0 = 0 ;
18126 PyObject * obj1 = 0 ;
18127 PyObject * obj2 = 0 ;
18128 char * kwnames[] = {
18129 (char *) "self",(char *) "row",(char *) "col", NULL
18130 };
18131
18132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18134 if (!SWIG_IsOK(res1)) {
18135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18136 }
18137 arg1 = reinterpret_cast< wxGrid * >(argp1);
18138 ecode2 = SWIG_AsVal_int(obj1, &val2);
18139 if (!SWIG_IsOK(ecode2)) {
18140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18141 }
18142 arg2 = static_cast< int >(val2);
18143 ecode3 = SWIG_AsVal_int(obj2, &val3);
18144 if (!SWIG_IsOK(ecode3)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18146 }
18147 arg3 = static_cast< int >(val3);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 {
18155 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj = 0;
18165 wxGrid *arg1 = (wxGrid *) 0 ;
18166 int arg2 ;
18167 int arg3 ;
18168 wxGridCellRenderer *result = 0 ;
18169 void *argp1 = 0 ;
18170 int res1 = 0 ;
18171 int val2 ;
18172 int ecode2 = 0 ;
18173 int val3 ;
18174 int ecode3 = 0 ;
18175 PyObject * obj0 = 0 ;
18176 PyObject * obj1 = 0 ;
18177 PyObject * obj2 = 0 ;
18178 char * kwnames[] = {
18179 (char *) "self",(char *) "row",(char *) "col", NULL
18180 };
18181
18182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18184 if (!SWIG_IsOK(res1)) {
18185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18186 }
18187 arg1 = reinterpret_cast< wxGrid * >(argp1);
18188 ecode2 = SWIG_AsVal_int(obj1, &val2);
18189 if (!SWIG_IsOK(ecode2)) {
18190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18191 }
18192 arg2 = static_cast< int >(val2);
18193 ecode3 = SWIG_AsVal_int(obj2, &val3);
18194 if (!SWIG_IsOK(ecode3)) {
18195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18196 }
18197 arg3 = static_cast< int >(val3);
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj = 0;
18215 wxGrid *arg1 = (wxGrid *) 0 ;
18216 wxString *arg2 = 0 ;
18217 wxGridCellEditor *result = 0 ;
18218 void *argp1 = 0 ;
18219 int res1 = 0 ;
18220 bool temp2 = false ;
18221 PyObject * obj0 = 0 ;
18222 PyObject * obj1 = 0 ;
18223 char * kwnames[] = {
18224 (char *) "self",(char *) "typeName", NULL
18225 };
18226
18227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18231 }
18232 arg1 = reinterpret_cast< wxGrid * >(argp1);
18233 {
18234 arg2 = wxString_in_helper(obj1);
18235 if (arg2 == NULL) SWIG_fail;
18236 temp2 = true;
18237 }
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18241 wxPyEndAllowThreads(__tstate);
18242 if (PyErr_Occurred()) SWIG_fail;
18243 }
18244 {
18245 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18246 }
18247 {
18248 if (temp2)
18249 delete arg2;
18250 }
18251 return resultobj;
18252 fail:
18253 {
18254 if (temp2)
18255 delete arg2;
18256 }
18257 return NULL;
18258 }
18259
18260
18261 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj = 0;
18263 wxGrid *arg1 = (wxGrid *) 0 ;
18264 wxString *arg2 = 0 ;
18265 wxGridCellRenderer *result = 0 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 bool temp2 = false ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 char * kwnames[] = {
18272 (char *) "self",(char *) "typeName", NULL
18273 };
18274
18275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18279 }
18280 arg1 = reinterpret_cast< wxGrid * >(argp1);
18281 {
18282 arg2 = wxString_in_helper(obj1);
18283 if (arg2 == NULL) SWIG_fail;
18284 temp2 = true;
18285 }
18286 {
18287 PyThreadState* __tstate = wxPyBeginAllowThreads();
18288 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 {
18293 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18294 }
18295 {
18296 if (temp2)
18297 delete arg2;
18298 }
18299 return resultobj;
18300 fail:
18301 {
18302 if (temp2)
18303 delete arg2;
18304 }
18305 return NULL;
18306 }
18307
18308
18309 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18310 PyObject *resultobj = 0;
18311 wxGrid *arg1 = (wxGrid *) 0 ;
18312 int arg2 ;
18313 int arg3 ;
18314 void *argp1 = 0 ;
18315 int res1 = 0 ;
18316 int val2 ;
18317 int ecode2 = 0 ;
18318 int val3 ;
18319 int ecode3 = 0 ;
18320 PyObject * obj0 = 0 ;
18321 PyObject * obj1 = 0 ;
18322 PyObject * obj2 = 0 ;
18323 char * kwnames[] = {
18324 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18325 };
18326
18327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18329 if (!SWIG_IsOK(res1)) {
18330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18331 }
18332 arg1 = reinterpret_cast< wxGrid * >(argp1);
18333 ecode2 = SWIG_AsVal_int(obj1, &val2);
18334 if (!SWIG_IsOK(ecode2)) {
18335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18336 }
18337 arg2 = static_cast< int >(val2);
18338 ecode3 = SWIG_AsVal_int(obj2, &val3);
18339 if (!SWIG_IsOK(ecode3)) {
18340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18341 }
18342 arg3 = static_cast< int >(val3);
18343 {
18344 PyThreadState* __tstate = wxPyBeginAllowThreads();
18345 (arg1)->SetMargins(arg2,arg3);
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 resultobj = SWIG_Py_Void();
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18357 PyObject *resultobj = 0;
18358 wxGrid *arg1 = (wxGrid *) 0 ;
18359 wxWindow *result = 0 ;
18360 void *argp1 = 0 ;
18361 int res1 = 0 ;
18362 PyObject *swig_obj[1] ;
18363
18364 if (!args) SWIG_fail;
18365 swig_obj[0] = args;
18366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18367 if (!SWIG_IsOK(res1)) {
18368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18369 }
18370 arg1 = reinterpret_cast< wxGrid * >(argp1);
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 result = (wxWindow *)(arg1)->GetGridWindow();
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 {
18378 resultobj = wxPyMake_wxObject(result, 0);
18379 }
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18387 PyObject *resultobj = 0;
18388 wxGrid *arg1 = (wxGrid *) 0 ;
18389 wxWindow *result = 0 ;
18390 void *argp1 = 0 ;
18391 int res1 = 0 ;
18392 PyObject *swig_obj[1] ;
18393
18394 if (!args) SWIG_fail;
18395 swig_obj[0] = args;
18396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18399 }
18400 arg1 = reinterpret_cast< wxGrid * >(argp1);
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 {
18408 resultobj = wxPyMake_wxObject(result, 0);
18409 }
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18417 PyObject *resultobj = 0;
18418 wxGrid *arg1 = (wxGrid *) 0 ;
18419 wxWindow *result = 0 ;
18420 void *argp1 = 0 ;
18421 int res1 = 0 ;
18422 PyObject *swig_obj[1] ;
18423
18424 if (!args) SWIG_fail;
18425 swig_obj[0] = args;
18426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18429 }
18430 arg1 = reinterpret_cast< wxGrid * >(argp1);
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = wxPyMake_wxObject(result, 0);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18447 PyObject *resultobj = 0;
18448 wxGrid *arg1 = (wxGrid *) 0 ;
18449 wxWindow *result = 0 ;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 PyObject *swig_obj[1] ;
18453
18454 if (!args) SWIG_fail;
18455 swig_obj[0] = args;
18456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18459 }
18460 arg1 = reinterpret_cast< wxGrid * >(argp1);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 {
18468 resultobj = wxPyMake_wxObject(result, 0);
18469 }
18470 return resultobj;
18471 fail:
18472 return NULL;
18473 }
18474
18475
18476 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj = 0;
18478 wxGrid *arg1 = (wxGrid *) 0 ;
18479 int arg2 ;
18480 void *argp1 = 0 ;
18481 int res1 = 0 ;
18482 int val2 ;
18483 int ecode2 = 0 ;
18484 PyObject * obj0 = 0 ;
18485 PyObject * obj1 = 0 ;
18486 char * kwnames[] = {
18487 (char *) "self",(char *) "x", NULL
18488 };
18489
18490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18492 if (!SWIG_IsOK(res1)) {
18493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18494 }
18495 arg1 = reinterpret_cast< wxGrid * >(argp1);
18496 ecode2 = SWIG_AsVal_int(obj1, &val2);
18497 if (!SWIG_IsOK(ecode2)) {
18498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18499 }
18500 arg2 = static_cast< int >(val2);
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 (arg1)->SetScrollLineX(arg2);
18504 wxPyEndAllowThreads(__tstate);
18505 if (PyErr_Occurred()) SWIG_fail;
18506 }
18507 resultobj = SWIG_Py_Void();
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj = 0;
18516 wxGrid *arg1 = (wxGrid *) 0 ;
18517 int arg2 ;
18518 void *argp1 = 0 ;
18519 int res1 = 0 ;
18520 int val2 ;
18521 int ecode2 = 0 ;
18522 PyObject * obj0 = 0 ;
18523 PyObject * obj1 = 0 ;
18524 char * kwnames[] = {
18525 (char *) "self",(char *) "y", NULL
18526 };
18527
18528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18532 }
18533 arg1 = reinterpret_cast< wxGrid * >(argp1);
18534 ecode2 = SWIG_AsVal_int(obj1, &val2);
18535 if (!SWIG_IsOK(ecode2)) {
18536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18537 }
18538 arg2 = static_cast< int >(val2);
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 (arg1)->SetScrollLineY(arg2);
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 resultobj = SWIG_Py_Void();
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18553 PyObject *resultobj = 0;
18554 wxGrid *arg1 = (wxGrid *) 0 ;
18555 int result;
18556 void *argp1 = 0 ;
18557 int res1 = 0 ;
18558 PyObject *swig_obj[1] ;
18559
18560 if (!args) SWIG_fail;
18561 swig_obj[0] = args;
18562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18563 if (!SWIG_IsOK(res1)) {
18564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18565 }
18566 arg1 = reinterpret_cast< wxGrid * >(argp1);
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 resultobj = SWIG_From_int(static_cast< int >(result));
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18581 PyObject *resultobj = 0;
18582 wxGrid *arg1 = (wxGrid *) 0 ;
18583 int result;
18584 void *argp1 = 0 ;
18585 int res1 = 0 ;
18586 PyObject *swig_obj[1] ;
18587
18588 if (!args) SWIG_fail;
18589 swig_obj[0] = args;
18590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18591 if (!SWIG_IsOK(res1)) {
18592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18593 }
18594 arg1 = reinterpret_cast< wxGrid * >(argp1);
18595 {
18596 PyThreadState* __tstate = wxPyBeginAllowThreads();
18597 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 resultobj = SWIG_From_int(static_cast< int >(result));
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = 0;
18610 wxGrid *arg1 = (wxGrid *) 0 ;
18611 int arg2 ;
18612 int result;
18613 void *argp1 = 0 ;
18614 int res1 = 0 ;
18615 int val2 ;
18616 int ecode2 = 0 ;
18617 PyObject * obj0 = 0 ;
18618 PyObject * obj1 = 0 ;
18619 char * kwnames[] = {
18620 (char *) "self",(char *) "x", NULL
18621 };
18622
18623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18625 if (!SWIG_IsOK(res1)) {
18626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18627 }
18628 arg1 = reinterpret_cast< wxGrid * >(argp1);
18629 ecode2 = SWIG_AsVal_int(obj1, &val2);
18630 if (!SWIG_IsOK(ecode2)) {
18631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18632 }
18633 arg2 = static_cast< int >(val2);
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 resultobj = SWIG_From_int(static_cast< int >(result));
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18648 PyObject *resultobj = 0;
18649 wxGrid *arg1 = (wxGrid *) 0 ;
18650 int arg2 ;
18651 int result;
18652 void *argp1 = 0 ;
18653 int res1 = 0 ;
18654 int val2 ;
18655 int ecode2 = 0 ;
18656 PyObject * obj0 = 0 ;
18657 PyObject * obj1 = 0 ;
18658 char * kwnames[] = {
18659 (char *) "self",(char *) "y", NULL
18660 };
18661
18662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18664 if (!SWIG_IsOK(res1)) {
18665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18666 }
18667 arg1 = reinterpret_cast< wxGrid * >(argp1);
18668 ecode2 = SWIG_AsVal_int(obj1, &val2);
18669 if (!SWIG_IsOK(ecode2)) {
18670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18671 }
18672 arg2 = static_cast< int >(val2);
18673 {
18674 PyThreadState* __tstate = wxPyBeginAllowThreads();
18675 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18676 wxPyEndAllowThreads(__tstate);
18677 if (PyErr_Occurred()) SWIG_fail;
18678 }
18679 resultobj = SWIG_From_int(static_cast< int >(result));
18680 return resultobj;
18681 fail:
18682 return NULL;
18683 }
18684
18685
18686 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18687 PyObject *resultobj = 0;
18688 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18689 SwigValueWrapper<wxVisualAttributes > result;
18690 int val1 ;
18691 int ecode1 = 0 ;
18692 PyObject * obj0 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "variant", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18698 if (obj0) {
18699 ecode1 = SWIG_AsVal_int(obj0, &val1);
18700 if (!SWIG_IsOK(ecode1)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18702 }
18703 arg1 = static_cast< wxWindowVariant >(val1);
18704 }
18705 {
18706 if (!wxPyCheckForApp()) SWIG_fail;
18707 PyThreadState* __tstate = wxPyBeginAllowThreads();
18708 result = wxGrid::GetClassDefaultAttributes(arg1);
18709 wxPyEndAllowThreads(__tstate);
18710 if (PyErr_Occurred()) SWIG_fail;
18711 }
18712 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18720 PyObject *obj;
18721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18722 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18723 return SWIG_Py_Void();
18724 }
18725
18726 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18727 return SWIG_Python_InitShadowInstance(args);
18728 }
18729
18730 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj = 0;
18732 int arg1 ;
18733 wxEventType arg2 ;
18734 wxGrid *arg3 = (wxGrid *) 0 ;
18735 int arg4 = (int) -1 ;
18736 int arg5 = (int) -1 ;
18737 int arg6 = (int) -1 ;
18738 int arg7 = (int) -1 ;
18739 bool arg8 = (bool) true ;
18740 bool arg9 = (bool) false ;
18741 bool arg10 = (bool) false ;
18742 bool arg11 = (bool) false ;
18743 bool arg12 = (bool) false ;
18744 wxGridEvent *result = 0 ;
18745 int val1 ;
18746 int ecode1 = 0 ;
18747 int val2 ;
18748 int ecode2 = 0 ;
18749 void *argp3 = 0 ;
18750 int res3 = 0 ;
18751 int val4 ;
18752 int ecode4 = 0 ;
18753 int val5 ;
18754 int ecode5 = 0 ;
18755 int val6 ;
18756 int ecode6 = 0 ;
18757 int val7 ;
18758 int ecode7 = 0 ;
18759 bool val8 ;
18760 int ecode8 = 0 ;
18761 bool val9 ;
18762 int ecode9 = 0 ;
18763 bool val10 ;
18764 int ecode10 = 0 ;
18765 bool val11 ;
18766 int ecode11 = 0 ;
18767 bool val12 ;
18768 int ecode12 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 PyObject * obj2 = 0 ;
18772 PyObject * obj3 = 0 ;
18773 PyObject * obj4 = 0 ;
18774 PyObject * obj5 = 0 ;
18775 PyObject * obj6 = 0 ;
18776 PyObject * obj7 = 0 ;
18777 PyObject * obj8 = 0 ;
18778 PyObject * obj9 = 0 ;
18779 PyObject * obj10 = 0 ;
18780 PyObject * obj11 = 0 ;
18781 char * kwnames[] = {
18782 (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
18783 };
18784
18785 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;
18786 ecode1 = SWIG_AsVal_int(obj0, &val1);
18787 if (!SWIG_IsOK(ecode1)) {
18788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18789 }
18790 arg1 = static_cast< int >(val1);
18791 ecode2 = SWIG_AsVal_int(obj1, &val2);
18792 if (!SWIG_IsOK(ecode2)) {
18793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18794 }
18795 arg2 = static_cast< wxEventType >(val2);
18796 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18797 if (!SWIG_IsOK(res3)) {
18798 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18799 }
18800 arg3 = reinterpret_cast< wxGrid * >(argp3);
18801 if (obj3) {
18802 ecode4 = SWIG_AsVal_int(obj3, &val4);
18803 if (!SWIG_IsOK(ecode4)) {
18804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18805 }
18806 arg4 = static_cast< int >(val4);
18807 }
18808 if (obj4) {
18809 ecode5 = SWIG_AsVal_int(obj4, &val5);
18810 if (!SWIG_IsOK(ecode5)) {
18811 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18812 }
18813 arg5 = static_cast< int >(val5);
18814 }
18815 if (obj5) {
18816 ecode6 = SWIG_AsVal_int(obj5, &val6);
18817 if (!SWIG_IsOK(ecode6)) {
18818 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18819 }
18820 arg6 = static_cast< int >(val6);
18821 }
18822 if (obj6) {
18823 ecode7 = SWIG_AsVal_int(obj6, &val7);
18824 if (!SWIG_IsOK(ecode7)) {
18825 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18826 }
18827 arg7 = static_cast< int >(val7);
18828 }
18829 if (obj7) {
18830 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18831 if (!SWIG_IsOK(ecode8)) {
18832 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18833 }
18834 arg8 = static_cast< bool >(val8);
18835 }
18836 if (obj8) {
18837 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18838 if (!SWIG_IsOK(ecode9)) {
18839 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18840 }
18841 arg9 = static_cast< bool >(val9);
18842 }
18843 if (obj9) {
18844 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18845 if (!SWIG_IsOK(ecode10)) {
18846 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18847 }
18848 arg10 = static_cast< bool >(val10);
18849 }
18850 if (obj10) {
18851 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18852 if (!SWIG_IsOK(ecode11)) {
18853 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18854 }
18855 arg11 = static_cast< bool >(val11);
18856 }
18857 if (obj11) {
18858 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18859 if (!SWIG_IsOK(ecode12)) {
18860 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18861 }
18862 arg12 = static_cast< bool >(val12);
18863 }
18864 {
18865 PyThreadState* __tstate = wxPyBeginAllowThreads();
18866 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878 PyObject *resultobj = 0;
18879 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18880 int 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_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18890 }
18891 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 result = (int)(arg1)->GetRow();
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 resultobj = SWIG_From_int(static_cast< int >(result));
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18906 PyObject *resultobj = 0;
18907 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18908 int result;
18909 void *argp1 = 0 ;
18910 int res1 = 0 ;
18911 PyObject *swig_obj[1] ;
18912
18913 if (!args) SWIG_fail;
18914 swig_obj[0] = args;
18915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18916 if (!SWIG_IsOK(res1)) {
18917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18918 }
18919 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (int)(arg1)->GetCol();
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_From_int(static_cast< int >(result));
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 PyObject *resultobj = 0;
18935 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18936 wxPoint result;
18937 void *argp1 = 0 ;
18938 int res1 = 0 ;
18939 PyObject *swig_obj[1] ;
18940
18941 if (!args) SWIG_fail;
18942 swig_obj[0] = args;
18943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18946 }
18947 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18948 {
18949 PyThreadState* __tstate = wxPyBeginAllowThreads();
18950 result = (arg1)->GetPosition();
18951 wxPyEndAllowThreads(__tstate);
18952 if (PyErr_Occurred()) SWIG_fail;
18953 }
18954 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18955 return resultobj;
18956 fail:
18957 return NULL;
18958 }
18959
18960
18961 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18962 PyObject *resultobj = 0;
18963 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18964 bool result;
18965 void *argp1 = 0 ;
18966 int res1 = 0 ;
18967 PyObject *swig_obj[1] ;
18968
18969 if (!args) SWIG_fail;
18970 swig_obj[0] = args;
18971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18972 if (!SWIG_IsOK(res1)) {
18973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18974 }
18975 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = (bool)(arg1)->Selecting();
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 {
18983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18984 }
18985 return resultobj;
18986 fail:
18987 return NULL;
18988 }
18989
18990
18991 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18992 PyObject *resultobj = 0;
18993 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18994 bool result;
18995 void *argp1 = 0 ;
18996 int res1 = 0 ;
18997 PyObject *swig_obj[1] ;
18998
18999 if (!args) SWIG_fail;
19000 swig_obj[0] = args;
19001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19002 if (!SWIG_IsOK(res1)) {
19003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19004 }
19005 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (bool)(arg1)->ControlDown();
19009 wxPyEndAllowThreads(__tstate);
19010 if (PyErr_Occurred()) SWIG_fail;
19011 }
19012 {
19013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19014 }
19015 return resultobj;
19016 fail:
19017 return NULL;
19018 }
19019
19020
19021 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19022 PyObject *resultobj = 0;
19023 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19024 bool result;
19025 void *argp1 = 0 ;
19026 int res1 = 0 ;
19027 PyObject *swig_obj[1] ;
19028
19029 if (!args) SWIG_fail;
19030 swig_obj[0] = args;
19031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19032 if (!SWIG_IsOK(res1)) {
19033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19034 }
19035 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19036 {
19037 PyThreadState* __tstate = wxPyBeginAllowThreads();
19038 result = (bool)(arg1)->MetaDown();
19039 wxPyEndAllowThreads(__tstate);
19040 if (PyErr_Occurred()) SWIG_fail;
19041 }
19042 {
19043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19044 }
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19052 PyObject *resultobj = 0;
19053 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19054 bool result;
19055 void *argp1 = 0 ;
19056 int res1 = 0 ;
19057 PyObject *swig_obj[1] ;
19058
19059 if (!args) SWIG_fail;
19060 swig_obj[0] = args;
19061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19064 }
19065 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (bool)(arg1)->ShiftDown();
19069 wxPyEndAllowThreads(__tstate);
19070 if (PyErr_Occurred()) SWIG_fail;
19071 }
19072 {
19073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19074 }
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19082 PyObject *resultobj = 0;
19083 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19084 bool result;
19085 void *argp1 = 0 ;
19086 int res1 = 0 ;
19087 PyObject *swig_obj[1] ;
19088
19089 if (!args) SWIG_fail;
19090 swig_obj[0] = args;
19091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19092 if (!SWIG_IsOK(res1)) {
19093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19094 }
19095 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19096 {
19097 PyThreadState* __tstate = wxPyBeginAllowThreads();
19098 result = (bool)(arg1)->AltDown();
19099 wxPyEndAllowThreads(__tstate);
19100 if (PyErr_Occurred()) SWIG_fail;
19101 }
19102 {
19103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19104 }
19105 return resultobj;
19106 fail:
19107 return NULL;
19108 }
19109
19110
19111 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19112 PyObject *resultobj = 0;
19113 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19114 bool result;
19115 void *argp1 = 0 ;
19116 int res1 = 0 ;
19117 PyObject *swig_obj[1] ;
19118
19119 if (!args) SWIG_fail;
19120 swig_obj[0] = args;
19121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19122 if (!SWIG_IsOK(res1)) {
19123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19124 }
19125 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19126 {
19127 PyThreadState* __tstate = wxPyBeginAllowThreads();
19128 result = (bool)(arg1)->CmdDown();
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19142 PyObject *obj;
19143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19144 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19145 return SWIG_Py_Void();
19146 }
19147
19148 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19149 return SWIG_Python_InitShadowInstance(args);
19150 }
19151
19152 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj = 0;
19154 int arg1 ;
19155 wxEventType arg2 ;
19156 wxGrid *arg3 = (wxGrid *) 0 ;
19157 int arg4 = (int) -1 ;
19158 int arg5 = (int) -1 ;
19159 int arg6 = (int) -1 ;
19160 bool arg7 = (bool) false ;
19161 bool arg8 = (bool) false ;
19162 bool arg9 = (bool) false ;
19163 bool arg10 = (bool) false ;
19164 wxGridSizeEvent *result = 0 ;
19165 int val1 ;
19166 int ecode1 = 0 ;
19167 int val2 ;
19168 int ecode2 = 0 ;
19169 void *argp3 = 0 ;
19170 int res3 = 0 ;
19171 int val4 ;
19172 int ecode4 = 0 ;
19173 int val5 ;
19174 int ecode5 = 0 ;
19175 int val6 ;
19176 int ecode6 = 0 ;
19177 bool val7 ;
19178 int ecode7 = 0 ;
19179 bool val8 ;
19180 int ecode8 = 0 ;
19181 bool val9 ;
19182 int ecode9 = 0 ;
19183 bool val10 ;
19184 int ecode10 = 0 ;
19185 PyObject * obj0 = 0 ;
19186 PyObject * obj1 = 0 ;
19187 PyObject * obj2 = 0 ;
19188 PyObject * obj3 = 0 ;
19189 PyObject * obj4 = 0 ;
19190 PyObject * obj5 = 0 ;
19191 PyObject * obj6 = 0 ;
19192 PyObject * obj7 = 0 ;
19193 PyObject * obj8 = 0 ;
19194 PyObject * obj9 = 0 ;
19195 char * kwnames[] = {
19196 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19197 };
19198
19199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19200 ecode1 = SWIG_AsVal_int(obj0, &val1);
19201 if (!SWIG_IsOK(ecode1)) {
19202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19203 }
19204 arg1 = static_cast< int >(val1);
19205 ecode2 = SWIG_AsVal_int(obj1, &val2);
19206 if (!SWIG_IsOK(ecode2)) {
19207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19208 }
19209 arg2 = static_cast< wxEventType >(val2);
19210 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19211 if (!SWIG_IsOK(res3)) {
19212 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19213 }
19214 arg3 = reinterpret_cast< wxGrid * >(argp3);
19215 if (obj3) {
19216 ecode4 = SWIG_AsVal_int(obj3, &val4);
19217 if (!SWIG_IsOK(ecode4)) {
19218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19219 }
19220 arg4 = static_cast< int >(val4);
19221 }
19222 if (obj4) {
19223 ecode5 = SWIG_AsVal_int(obj4, &val5);
19224 if (!SWIG_IsOK(ecode5)) {
19225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19226 }
19227 arg5 = static_cast< int >(val5);
19228 }
19229 if (obj5) {
19230 ecode6 = SWIG_AsVal_int(obj5, &val6);
19231 if (!SWIG_IsOK(ecode6)) {
19232 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19233 }
19234 arg6 = static_cast< int >(val6);
19235 }
19236 if (obj6) {
19237 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19238 if (!SWIG_IsOK(ecode7)) {
19239 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19240 }
19241 arg7 = static_cast< bool >(val7);
19242 }
19243 if (obj7) {
19244 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19245 if (!SWIG_IsOK(ecode8)) {
19246 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19247 }
19248 arg8 = static_cast< bool >(val8);
19249 }
19250 if (obj8) {
19251 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19252 if (!SWIG_IsOK(ecode9)) {
19253 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19254 }
19255 arg9 = static_cast< bool >(val9);
19256 }
19257 if (obj9) {
19258 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19259 if (!SWIG_IsOK(ecode10)) {
19260 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19261 }
19262 arg10 = static_cast< bool >(val10);
19263 }
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19278 PyObject *resultobj = 0;
19279 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19280 int result;
19281 void *argp1 = 0 ;
19282 int res1 = 0 ;
19283 PyObject *swig_obj[1] ;
19284
19285 if (!args) SWIG_fail;
19286 swig_obj[0] = args;
19287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19288 if (!SWIG_IsOK(res1)) {
19289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19290 }
19291 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = (int)(arg1)->GetRowOrCol();
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 resultobj = SWIG_From_int(static_cast< int >(result));
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19306 PyObject *resultobj = 0;
19307 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19308 wxPoint result;
19309 void *argp1 = 0 ;
19310 int res1 = 0 ;
19311 PyObject *swig_obj[1] ;
19312
19313 if (!args) SWIG_fail;
19314 swig_obj[0] = args;
19315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19316 if (!SWIG_IsOK(res1)) {
19317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19318 }
19319 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 result = (arg1)->GetPosition();
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 PyObject *resultobj = 0;
19335 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19336 bool result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 PyObject *swig_obj[1] ;
19340
19341 if (!args) SWIG_fail;
19342 swig_obj[0] = args;
19343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19344 if (!SWIG_IsOK(res1)) {
19345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19346 }
19347 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19348 {
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 result = (bool)(arg1)->ControlDown();
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 {
19355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19356 }
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19364 PyObject *resultobj = 0;
19365 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19366 bool result;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 PyObject *swig_obj[1] ;
19370
19371 if (!args) SWIG_fail;
19372 swig_obj[0] = args;
19373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19374 if (!SWIG_IsOK(res1)) {
19375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19376 }
19377 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (bool)(arg1)->MetaDown();
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 {
19385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19386 }
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19394 PyObject *resultobj = 0;
19395 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19396 bool result;
19397 void *argp1 = 0 ;
19398 int res1 = 0 ;
19399 PyObject *swig_obj[1] ;
19400
19401 if (!args) SWIG_fail;
19402 swig_obj[0] = args;
19403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19404 if (!SWIG_IsOK(res1)) {
19405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19406 }
19407 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 result = (bool)(arg1)->ShiftDown();
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 {
19415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19416 }
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19424 PyObject *resultobj = 0;
19425 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19426 bool result;
19427 void *argp1 = 0 ;
19428 int res1 = 0 ;
19429 PyObject *swig_obj[1] ;
19430
19431 if (!args) SWIG_fail;
19432 swig_obj[0] = args;
19433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19434 if (!SWIG_IsOK(res1)) {
19435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19436 }
19437 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (bool)(arg1)->AltDown();
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 {
19445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19446 }
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19454 PyObject *resultobj = 0;
19455 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19456 bool result;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 PyObject *swig_obj[1] ;
19460
19461 if (!args) SWIG_fail;
19462 swig_obj[0] = args;
19463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19464 if (!SWIG_IsOK(res1)) {
19465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19466 }
19467 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = (bool)(arg1)->CmdDown();
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19484 PyObject *obj;
19485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19486 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19487 return SWIG_Py_Void();
19488 }
19489
19490 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19491 return SWIG_Python_InitShadowInstance(args);
19492 }
19493
19494 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19495 PyObject *resultobj = 0;
19496 int arg1 ;
19497 wxEventType arg2 ;
19498 wxGrid *arg3 = (wxGrid *) 0 ;
19499 wxGridCellCoords *arg4 = 0 ;
19500 wxGridCellCoords *arg5 = 0 ;
19501 bool arg6 = (bool) true ;
19502 bool arg7 = (bool) false ;
19503 bool arg8 = (bool) false ;
19504 bool arg9 = (bool) false ;
19505 bool arg10 = (bool) false ;
19506 wxGridRangeSelectEvent *result = 0 ;
19507 int val1 ;
19508 int ecode1 = 0 ;
19509 int val2 ;
19510 int ecode2 = 0 ;
19511 void *argp3 = 0 ;
19512 int res3 = 0 ;
19513 wxGridCellCoords temp4 ;
19514 wxGridCellCoords temp5 ;
19515 bool val6 ;
19516 int ecode6 = 0 ;
19517 bool val7 ;
19518 int ecode7 = 0 ;
19519 bool val8 ;
19520 int ecode8 = 0 ;
19521 bool val9 ;
19522 int ecode9 = 0 ;
19523 bool val10 ;
19524 int ecode10 = 0 ;
19525 PyObject * obj0 = 0 ;
19526 PyObject * obj1 = 0 ;
19527 PyObject * obj2 = 0 ;
19528 PyObject * obj3 = 0 ;
19529 PyObject * obj4 = 0 ;
19530 PyObject * obj5 = 0 ;
19531 PyObject * obj6 = 0 ;
19532 PyObject * obj7 = 0 ;
19533 PyObject * obj8 = 0 ;
19534 PyObject * obj9 = 0 ;
19535 char * kwnames[] = {
19536 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19537 };
19538
19539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19540 ecode1 = SWIG_AsVal_int(obj0, &val1);
19541 if (!SWIG_IsOK(ecode1)) {
19542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19543 }
19544 arg1 = static_cast< int >(val1);
19545 ecode2 = SWIG_AsVal_int(obj1, &val2);
19546 if (!SWIG_IsOK(ecode2)) {
19547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19548 }
19549 arg2 = static_cast< wxEventType >(val2);
19550 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19551 if (!SWIG_IsOK(res3)) {
19552 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19553 }
19554 arg3 = reinterpret_cast< wxGrid * >(argp3);
19555 {
19556 arg4 = &temp4;
19557 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19558 }
19559 {
19560 arg5 = &temp5;
19561 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19562 }
19563 if (obj5) {
19564 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19565 if (!SWIG_IsOK(ecode6)) {
19566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19567 }
19568 arg6 = static_cast< bool >(val6);
19569 }
19570 if (obj6) {
19571 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19572 if (!SWIG_IsOK(ecode7)) {
19573 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19574 }
19575 arg7 = static_cast< bool >(val7);
19576 }
19577 if (obj7) {
19578 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19579 if (!SWIG_IsOK(ecode8)) {
19580 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19581 }
19582 arg8 = static_cast< bool >(val8);
19583 }
19584 if (obj8) {
19585 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19586 if (!SWIG_IsOK(ecode9)) {
19587 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19588 }
19589 arg9 = static_cast< bool >(val9);
19590 }
19591 if (obj9) {
19592 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19593 if (!SWIG_IsOK(ecode10)) {
19594 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19595 }
19596 arg10 = static_cast< bool >(val10);
19597 }
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19612 PyObject *resultobj = 0;
19613 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19614 wxGridCellCoords result;
19615 void *argp1 = 0 ;
19616 int res1 = 0 ;
19617 PyObject *swig_obj[1] ;
19618
19619 if (!args) SWIG_fail;
19620 swig_obj[0] = args;
19621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19622 if (!SWIG_IsOK(res1)) {
19623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19624 }
19625 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19626 {
19627 PyThreadState* __tstate = wxPyBeginAllowThreads();
19628 result = (arg1)->GetTopLeftCoords();
19629 wxPyEndAllowThreads(__tstate);
19630 if (PyErr_Occurred()) SWIG_fail;
19631 }
19632 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19633 return resultobj;
19634 fail:
19635 return NULL;
19636 }
19637
19638
19639 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19640 PyObject *resultobj = 0;
19641 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19642 wxGridCellCoords result;
19643 void *argp1 = 0 ;
19644 int res1 = 0 ;
19645 PyObject *swig_obj[1] ;
19646
19647 if (!args) SWIG_fail;
19648 swig_obj[0] = args;
19649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19650 if (!SWIG_IsOK(res1)) {
19651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19652 }
19653 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 result = (arg1)->GetBottomRightCoords();
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19668 PyObject *resultobj = 0;
19669 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19670 int result;
19671 void *argp1 = 0 ;
19672 int res1 = 0 ;
19673 PyObject *swig_obj[1] ;
19674
19675 if (!args) SWIG_fail;
19676 swig_obj[0] = args;
19677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19678 if (!SWIG_IsOK(res1)) {
19679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19680 }
19681 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 result = (int)(arg1)->GetTopRow();
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 resultobj = SWIG_From_int(static_cast< int >(result));
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19696 PyObject *resultobj = 0;
19697 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19698 int 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_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19708 }
19709 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = (int)(arg1)->GetBottomRow();
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_From_int(static_cast< int >(result));
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19724 PyObject *resultobj = 0;
19725 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19726 int result;
19727 void *argp1 = 0 ;
19728 int res1 = 0 ;
19729 PyObject *swig_obj[1] ;
19730
19731 if (!args) SWIG_fail;
19732 swig_obj[0] = args;
19733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19736 }
19737 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 result = (int)(arg1)->GetLeftCol();
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 resultobj = SWIG_From_int(static_cast< int >(result));
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19752 PyObject *resultobj = 0;
19753 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19754 int result;
19755 void *argp1 = 0 ;
19756 int res1 = 0 ;
19757 PyObject *swig_obj[1] ;
19758
19759 if (!args) SWIG_fail;
19760 swig_obj[0] = args;
19761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19762 if (!SWIG_IsOK(res1)) {
19763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19764 }
19765 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 result = (int)(arg1)->GetRightCol();
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = SWIG_From_int(static_cast< int >(result));
19773 return resultobj;
19774 fail:
19775 return NULL;
19776 }
19777
19778
19779 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19780 PyObject *resultobj = 0;
19781 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19782 bool result;
19783 void *argp1 = 0 ;
19784 int res1 = 0 ;
19785 PyObject *swig_obj[1] ;
19786
19787 if (!args) SWIG_fail;
19788 swig_obj[0] = args;
19789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19792 }
19793 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = (bool)(arg1)->Selecting();
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 {
19801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19802 }
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19810 PyObject *resultobj = 0;
19811 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19812 bool result;
19813 void *argp1 = 0 ;
19814 int res1 = 0 ;
19815 PyObject *swig_obj[1] ;
19816
19817 if (!args) SWIG_fail;
19818 swig_obj[0] = args;
19819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19820 if (!SWIG_IsOK(res1)) {
19821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19822 }
19823 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (bool)(arg1)->ControlDown();
19827 wxPyEndAllowThreads(__tstate);
19828 if (PyErr_Occurred()) SWIG_fail;
19829 }
19830 {
19831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19832 }
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19840 PyObject *resultobj = 0;
19841 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19842 bool 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_wxGridRangeSelectEvent, 0 | 0 );
19850 if (!SWIG_IsOK(res1)) {
19851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19852 }
19853 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 result = (bool)(arg1)->MetaDown();
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 {
19861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19862 }
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19870 PyObject *resultobj = 0;
19871 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19872 bool result;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 PyObject *swig_obj[1] ;
19876
19877 if (!args) SWIG_fail;
19878 swig_obj[0] = args;
19879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19880 if (!SWIG_IsOK(res1)) {
19881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19882 }
19883 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 result = (bool)(arg1)->ShiftDown();
19887 wxPyEndAllowThreads(__tstate);
19888 if (PyErr_Occurred()) SWIG_fail;
19889 }
19890 {
19891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19892 }
19893 return resultobj;
19894 fail:
19895 return NULL;
19896 }
19897
19898
19899 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19900 PyObject *resultobj = 0;
19901 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19902 bool result;
19903 void *argp1 = 0 ;
19904 int res1 = 0 ;
19905 PyObject *swig_obj[1] ;
19906
19907 if (!args) SWIG_fail;
19908 swig_obj[0] = args;
19909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19910 if (!SWIG_IsOK(res1)) {
19911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19912 }
19913 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19914 {
19915 PyThreadState* __tstate = wxPyBeginAllowThreads();
19916 result = (bool)(arg1)->AltDown();
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 {
19921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19922 }
19923 return resultobj;
19924 fail:
19925 return NULL;
19926 }
19927
19928
19929 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19930 PyObject *resultobj = 0;
19931 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19932 bool result;
19933 void *argp1 = 0 ;
19934 int res1 = 0 ;
19935 PyObject *swig_obj[1] ;
19936
19937 if (!args) SWIG_fail;
19938 swig_obj[0] = args;
19939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19940 if (!SWIG_IsOK(res1)) {
19941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19942 }
19943 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19944 {
19945 PyThreadState* __tstate = wxPyBeginAllowThreads();
19946 result = (bool)(arg1)->CmdDown();
19947 wxPyEndAllowThreads(__tstate);
19948 if (PyErr_Occurred()) SWIG_fail;
19949 }
19950 {
19951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19952 }
19953 return resultobj;
19954 fail:
19955 return NULL;
19956 }
19957
19958
19959 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19960 PyObject *obj;
19961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19962 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19963 return SWIG_Py_Void();
19964 }
19965
19966 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19967 return SWIG_Python_InitShadowInstance(args);
19968 }
19969
19970 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19971 PyObject *resultobj = 0;
19972 int arg1 ;
19973 wxEventType arg2 ;
19974 wxObject *arg3 = (wxObject *) 0 ;
19975 int arg4 ;
19976 int arg5 ;
19977 wxControl *arg6 = (wxControl *) 0 ;
19978 wxGridEditorCreatedEvent *result = 0 ;
19979 int val1 ;
19980 int ecode1 = 0 ;
19981 int val2 ;
19982 int ecode2 = 0 ;
19983 void *argp3 = 0 ;
19984 int res3 = 0 ;
19985 int val4 ;
19986 int ecode4 = 0 ;
19987 int val5 ;
19988 int ecode5 = 0 ;
19989 void *argp6 = 0 ;
19990 int res6 = 0 ;
19991 PyObject * obj0 = 0 ;
19992 PyObject * obj1 = 0 ;
19993 PyObject * obj2 = 0 ;
19994 PyObject * obj3 = 0 ;
19995 PyObject * obj4 = 0 ;
19996 PyObject * obj5 = 0 ;
19997 char * kwnames[] = {
19998 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
19999 };
20000
20001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20002 ecode1 = SWIG_AsVal_int(obj0, &val1);
20003 if (!SWIG_IsOK(ecode1)) {
20004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20005 }
20006 arg1 = static_cast< int >(val1);
20007 ecode2 = SWIG_AsVal_int(obj1, &val2);
20008 if (!SWIG_IsOK(ecode2)) {
20009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20010 }
20011 arg2 = static_cast< wxEventType >(val2);
20012 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20013 if (!SWIG_IsOK(res3)) {
20014 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20015 }
20016 arg3 = reinterpret_cast< wxObject * >(argp3);
20017 ecode4 = SWIG_AsVal_int(obj3, &val4);
20018 if (!SWIG_IsOK(ecode4)) {
20019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20020 }
20021 arg4 = static_cast< int >(val4);
20022 ecode5 = SWIG_AsVal_int(obj4, &val5);
20023 if (!SWIG_IsOK(ecode5)) {
20024 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20025 }
20026 arg5 = static_cast< int >(val5);
20027 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20028 if (!SWIG_IsOK(res6)) {
20029 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20030 }
20031 arg6 = reinterpret_cast< wxControl * >(argp6);
20032 {
20033 PyThreadState* __tstate = wxPyBeginAllowThreads();
20034 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20035 wxPyEndAllowThreads(__tstate);
20036 if (PyErr_Occurred()) SWIG_fail;
20037 }
20038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20046 PyObject *resultobj = 0;
20047 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20048 int result;
20049 void *argp1 = 0 ;
20050 int res1 = 0 ;
20051 PyObject *swig_obj[1] ;
20052
20053 if (!args) SWIG_fail;
20054 swig_obj[0] = args;
20055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20056 if (!SWIG_IsOK(res1)) {
20057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20058 }
20059 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (int)(arg1)->GetRow();
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_From_int(static_cast< int >(result));
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20074 PyObject *resultobj = 0;
20075 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20076 int result;
20077 void *argp1 = 0 ;
20078 int res1 = 0 ;
20079 PyObject *swig_obj[1] ;
20080
20081 if (!args) SWIG_fail;
20082 swig_obj[0] = args;
20083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20084 if (!SWIG_IsOK(res1)) {
20085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20086 }
20087 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (int)(arg1)->GetCol();
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 resultobj = SWIG_From_int(static_cast< int >(result));
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20102 PyObject *resultobj = 0;
20103 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20104 wxControl *result = 0 ;
20105 void *argp1 = 0 ;
20106 int res1 = 0 ;
20107 PyObject *swig_obj[1] ;
20108
20109 if (!args) SWIG_fail;
20110 swig_obj[0] = args;
20111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20112 if (!SWIG_IsOK(res1)) {
20113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20114 }
20115 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (wxControl *)(arg1)->GetControl();
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = wxPyMake_wxObject(result, 0);
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20132 PyObject *resultobj = 0;
20133 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20134 int arg2 ;
20135 void *argp1 = 0 ;
20136 int res1 = 0 ;
20137 int val2 ;
20138 int ecode2 = 0 ;
20139 PyObject * obj0 = 0 ;
20140 PyObject * obj1 = 0 ;
20141 char * kwnames[] = {
20142 (char *) "self",(char *) "row", NULL
20143 };
20144
20145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20147 if (!SWIG_IsOK(res1)) {
20148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20149 }
20150 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20151 ecode2 = SWIG_AsVal_int(obj1, &val2);
20152 if (!SWIG_IsOK(ecode2)) {
20153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20154 }
20155 arg2 = static_cast< int >(val2);
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 (arg1)->SetRow(arg2);
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 resultobj = SWIG_Py_Void();
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj = 0;
20171 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20172 int arg2 ;
20173 void *argp1 = 0 ;
20174 int res1 = 0 ;
20175 int val2 ;
20176 int ecode2 = 0 ;
20177 PyObject * obj0 = 0 ;
20178 PyObject * obj1 = 0 ;
20179 char * kwnames[] = {
20180 (char *) "self",(char *) "col", NULL
20181 };
20182
20183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20187 }
20188 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20189 ecode2 = SWIG_AsVal_int(obj1, &val2);
20190 if (!SWIG_IsOK(ecode2)) {
20191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20192 }
20193 arg2 = static_cast< int >(val2);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 (arg1)->SetCol(arg2);
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 resultobj = SWIG_Py_Void();
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20208 PyObject *resultobj = 0;
20209 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20210 wxControl *arg2 = (wxControl *) 0 ;
20211 void *argp1 = 0 ;
20212 int res1 = 0 ;
20213 void *argp2 = 0 ;
20214 int res2 = 0 ;
20215 PyObject * obj0 = 0 ;
20216 PyObject * obj1 = 0 ;
20217 char * kwnames[] = {
20218 (char *) "self",(char *) "ctrl", NULL
20219 };
20220
20221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20223 if (!SWIG_IsOK(res1)) {
20224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20225 }
20226 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20228 if (!SWIG_IsOK(res2)) {
20229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20230 }
20231 arg2 = reinterpret_cast< wxControl * >(argp2);
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 (arg1)->SetControl(arg2);
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 resultobj = SWIG_Py_Void();
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 PyObject *obj;
20247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20248 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20249 return SWIG_Py_Void();
20250 }
20251
20252 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20253 return SWIG_Python_InitShadowInstance(args);
20254 }
20255
20256 static PyMethodDef SwigMethods[] = {
20257 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20258 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20259 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20260 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20261 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20262 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20263 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20264 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20265 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20266 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20267 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20268 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20269 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20270 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20271 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20272 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20273 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20274 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20275 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20276 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20277 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20278 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20279 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20280 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20281 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20282 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20283 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20284 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20285 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20286 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20287 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20288 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20289 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20290 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20291 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20292 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20293 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20294 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20295 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20296 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20297 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20298 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20299 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20300 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20301 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20302 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20303 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20304 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20305 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20306 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20307 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20308 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20309 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20310 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20312 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20313 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20314 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20315 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20316 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20317 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20318 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20319 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20320 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20321 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20322 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20323 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20324 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20325 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20326 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20327 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20328 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20329 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20330 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20331 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20332 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20333 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20334 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20335 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20336 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20337 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20338 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20339 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20340 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20341 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20342 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20343 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20344 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20345 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20346 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20347 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20348 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20349 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20350 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20351 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20353 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20355 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20358 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20360 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20361 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20362 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20363 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20364 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20365 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20366 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20367 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20368 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20369 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20370 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20371 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20372 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20373 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20374 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20375 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20376 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20377 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20379 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20380 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20381 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20384 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20385 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20389 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20390 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20391 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20397 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20398 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20399 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20402 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20403 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20404 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20405 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20406 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20407 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20408 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20409 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20419 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20424 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20430 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20435 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20436 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20438 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20439 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20440 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20441 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20442 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20443 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20445 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20447 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20448 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20449 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20451 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20452 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20453 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20454 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20455 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20457 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20458 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20460 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20462 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20465 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20466 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20467 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20469 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20473 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20474 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20475 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20477 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20479 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20489 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20490 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20491 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20492 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20493 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20496 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20497 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20498 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20499 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20500 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20501 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20502 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20503 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20510 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20511 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20519 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20520 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20525 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20526 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20527 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20528 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20529 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20530 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20531 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20532 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20533 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20534 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20537 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20538 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20539 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20540 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20556 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20557 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20559 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20560 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20562 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20563 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20565 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20566 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20568 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20569 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20579 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20580 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20582 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20584 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20586 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20588 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20590 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20592 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20606 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20613 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20614 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20628 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20632 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20641 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20642 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20643 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20645 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20646 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20647 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20648 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20649 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20654 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20655 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20664 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20665 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20666 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20667 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20670 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20671 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20675 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20676 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20678 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20679 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20680 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20681 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20682 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20683 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20684 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20685 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20686 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20687 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20688 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20690 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20691 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20692 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20693 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20694 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20695 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20696 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20697 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20698 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20700 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20701 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20702 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20703 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20704 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20705 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20706 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20707 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20708 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20709 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20710 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20711 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20712 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20713 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20715 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20716 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20717 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20721 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20722 { NULL, NULL, 0, NULL }
20723 };
20724
20725
20726 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20727
20728 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20729 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20730 }
20731 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20732 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20733 }
20734 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20735 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20736 }
20737 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20738 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20739 }
20740 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20741 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20742 }
20743 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20744 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20745 }
20746 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20747 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20748 }
20749 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20750 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20751 }
20752 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20753 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20754 }
20755 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20756 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20757 }
20758 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20759 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20760 }
20761 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20762 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20763 }
20764 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20765 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20766 }
20767 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20768 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20769 }
20770 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20771 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20772 }
20773 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20774 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20775 }
20776 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20777 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20778 }
20779 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20780 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20781 }
20782 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20783 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20784 }
20785 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20786 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20787 }
20788 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20789 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20790 }
20791 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20792 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20793 }
20794 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20795 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20796 }
20797 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20798 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20799 }
20800 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20801 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20802 }
20803 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20804 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20805 }
20806 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20807 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20808 }
20809 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20810 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20811 }
20812 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20813 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20814 }
20815 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20816 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20817 }
20818 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20819 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20820 }
20821 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20822 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20823 }
20824 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20825 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20826 }
20827 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20828 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20829 }
20830 static void *_p_wxGridTo_p_wxPanel(void *x) {
20831 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20832 }
20833 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20834 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20835 }
20836 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20837 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20838 }
20839 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20840 return (void *)((wxPanel *) ((wxPyPanel *) x));
20841 }
20842 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20843 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20844 }
20845 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20846 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20847 }
20848 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20849 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20850 }
20851 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20852 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20853 }
20854 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20855 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20856 }
20857 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20858 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20859 }
20860 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20861 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20862 }
20863 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20864 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20865 }
20866 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20867 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20868 }
20869 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20870 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20871 }
20872 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20873 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20874 }
20875 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20876 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20877 }
20878 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20879 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20880 }
20881 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20882 return (void *)((wxWindow *) ((wxMenuBar *) x));
20883 }
20884 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20885 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20886 }
20887 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20888 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20889 }
20890 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20891 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20892 }
20893 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20894 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20895 }
20896 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20897 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20898 }
20899 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20900 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20901 }
20902 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20903 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20904 }
20905 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20906 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20907 }
20908 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20909 return (void *)((wxWindow *) ((wxPanel *) x));
20910 }
20911 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20912 return (void *)((wxWindow *) ((wxStatusBar *) x));
20913 }
20914 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20915 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20916 }
20917 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20918 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
20919 }
20920 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20921 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20922 }
20923 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20924 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20925 }
20926 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20927 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20928 }
20929 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20930 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20931 }
20932 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20933 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20934 }
20935 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20936 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20937 }
20938 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20939 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20940 }
20941 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20942 return (void *)((wxWindow *) ((wxSashWindow *) x));
20943 }
20944 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20945 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20946 }
20947 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20948 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20949 }
20950 static void *_p_wxControlTo_p_wxWindow(void *x) {
20951 return (void *)((wxWindow *) ((wxControl *) x));
20952 }
20953 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20954 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20955 }
20956 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20957 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20958 }
20959 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20960 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20961 }
20962 static void *_p_wxGridTo_p_wxWindow(void *x) {
20963 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20964 }
20965 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20966 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20967 }
20968 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20969 return (void *)((wxWindow *) ((wxPyWindow *) x));
20970 }
20971 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20972 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20973 }
20974 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20975 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20976 }
20977 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20978 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20979 }
20980 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20981 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20982 }
20983 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20984 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20985 }
20986 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20987 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20988 }
20989 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20990 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20991 }
20992 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20993 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20994 }
20995 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
20996 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
20997 }
20998 static void *_p_wxDialogTo_p_wxWindow(void *x) {
20999 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21000 }
21001 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21002 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21003 }
21004 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21005 return (void *)((wxControl *) ((wxControlWithItems *) x));
21006 }
21007 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21008 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21009 }
21010 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21011 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21012 }
21013 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21014 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21015 }
21016 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21017 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21018 }
21019 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21020 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21021 }
21022 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21023 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21024 }
21025 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21026 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21027 }
21028 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21029 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21030 }
21031 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21032 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21033 }
21034 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21035 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21036 }
21037 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21039 }
21040 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21041 return (void *)((wxEvent *) ((wxPyEvent *) x));
21042 }
21043 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21044 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21045 }
21046 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21047 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21048 }
21049 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21050 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21051 }
21052 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21053 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21054 }
21055 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21056 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21057 }
21058 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21059 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21060 }
21061 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21062 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21063 }
21064 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21065 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21066 }
21067 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21068 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21069 }
21070 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21071 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21072 }
21073 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21075 }
21076 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21077 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21078 }
21079 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21080 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21081 }
21082 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21083 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21084 }
21085 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21086 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21087 }
21088 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21089 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21090 }
21091 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21092 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21093 }
21094 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21095 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21096 }
21097 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21098 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21099 }
21100 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21101 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21102 }
21103 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21104 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21105 }
21106 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21107 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21108 }
21109 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21110 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21111 }
21112 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21113 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21114 }
21115 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21116 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21117 }
21118 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21119 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21120 }
21121 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21122 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21123 }
21124 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21125 return (void *)((wxEvent *) ((wxShowEvent *) x));
21126 }
21127 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21128 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21129 }
21130 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21131 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21132 }
21133 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21134 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21135 }
21136 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21137 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21138 }
21139 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21140 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21141 }
21142 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21143 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21144 }
21145 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21146 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21147 }
21148 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21150 }
21151 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21153 }
21154 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21156 }
21157 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21159 }
21160 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21162 }
21163 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) ((wxSizerItem *) x));
21165 }
21166 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21168 }
21169 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21171 }
21172 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21174 }
21175 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21177 }
21178 static void *_p_wxSizerTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) ((wxSizer *) x));
21180 }
21181 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21183 }
21184 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21186 }
21187 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21189 }
21190 static void *_p_wxEventTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) ((wxEvent *) x));
21192 }
21193 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) ((wxFontData *) x));
21195 }
21196 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) ((wxPrintData *) x));
21198 }
21199 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21201 }
21202 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21204 }
21205 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21207 }
21208 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21210 }
21211 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21213 }
21214 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21216 }
21217 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21219 }
21220 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21222 }
21223 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21225 }
21226 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21228 }
21229 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21231 }
21232 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21234 }
21235 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21237 }
21238 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21240 }
21241 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21243 }
21244 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21246 }
21247 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21249 }
21250 static void *_p_wxControlTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21252 }
21253 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21255 }
21256 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21258 }
21259 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) ((wxFSFile *) x));
21261 }
21262 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21264 }
21265 static void *_p_wxGridTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21267 }
21268 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21270 }
21271 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21273 }
21274 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) ((wxColourData *) x));
21276 }
21277 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21279 }
21280 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21282 }
21283 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21285 }
21286 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21288 }
21289 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21291 }
21292 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21294 }
21295 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21297 }
21298 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21300 }
21301 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21303 }
21304 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21306 }
21307 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21309 }
21310 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21312 }
21313 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21315 }
21316 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) ((wxPrinter *) x));
21318 }
21319 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) ((wxMenuItem *) x));
21321 }
21322 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21324 }
21325 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21327 }
21328 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21330 }
21331 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21333 }
21334 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21336 }
21337 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21339 }
21340 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21342 }
21343 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21345 }
21346 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21348 }
21349 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21351 }
21352 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21354 }
21355 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21356 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21357 }
21358 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21359 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21360 }
21361 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21362 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21363 }
21364 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21365 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21366 }
21367 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21368 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21369 }
21370 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21371 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21372 }
21373 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21374 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21375 }
21376 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21377 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21378 }
21379 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21380 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21381 }
21382 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21383 return (void *)((wxObject *) ((wxImageHandler *) x));
21384 }
21385 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21386 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21387 }
21388 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21389 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21390 }
21391 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21392 return (void *)((wxObject *) ((wxEvtHandler *) x));
21393 }
21394 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21395 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21396 }
21397 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21398 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21399 }
21400 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21401 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21402 }
21403 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21404 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21405 }
21406 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21407 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21408 }
21409 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21410 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21411 }
21412 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21413 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21414 }
21415 static void *_p_wxImageTo_p_wxObject(void *x) {
21416 return (void *)((wxObject *) ((wxImage *) x));
21417 }
21418 static void *_p_wxFrameTo_p_wxObject(void *x) {
21419 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21420 }
21421 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21422 return (void *)((wxObject *) ((wxPyPrintout *) x));
21423 }
21424 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21425 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21426 }
21427 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21428 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21429 }
21430 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21431 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21432 }
21433 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21434 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21435 }
21436 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21437 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21438 }
21439 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21440 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21441 }
21442 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21443 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21444 }
21445 static void *_p_wxWindowTo_p_wxObject(void *x) {
21446 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21447 }
21448 static void *_p_wxMenuTo_p_wxObject(void *x) {
21449 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21450 }
21451 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21452 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21453 }
21454 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21455 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21456 }
21457 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21458 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21459 }
21460 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21461 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21462 }
21463 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21464 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21465 }
21466 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21467 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21468 }
21469 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21470 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21471 }
21472 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21473 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21474 }
21475 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21476 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21477 }
21478 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21479 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21480 }
21481 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21482 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21483 }
21484 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21485 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21486 }
21487 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21488 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21489 }
21490 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21491 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21492 }
21493 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21494 return (void *)((wxObject *) ((wxPrintPreview *) x));
21495 }
21496 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21497 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21498 }
21499 static void *_p_wxPanelTo_p_wxObject(void *x) {
21500 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21501 }
21502 static void *_p_wxDialogTo_p_wxObject(void *x) {
21503 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21504 }
21505 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21506 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21507 }
21508 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21509 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21510 }
21511 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21512 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21513 }
21514 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21515 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21516 }
21517 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21518 return (void *)((wxObject *) ((wxPrintDialog *) x));
21519 }
21520 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21521 return (void *)((wxObject *) ((wxFileSystem *) x));
21522 }
21523 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21525 }
21526 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21527 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21528 }
21529 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21530 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21531 }
21532 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21533 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21534 }
21535 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21536 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21537 }
21538 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21539 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21540 }
21541 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21542 return (void *)((wxObject *) ((wxGridTableBase *) x));
21543 }
21544 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21545 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21546 }
21547 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21548 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21549 }
21550 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21551 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21552 }
21553 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21554 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21555 }
21556 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21557 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21558 }
21559 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21560 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21561 }
21562 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21563 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21564 }
21565 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21567 }
21568 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21569 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21570 }
21571 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21572 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21573 }
21574 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21575 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21576 }
21577 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21578 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21579 }
21580 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21581 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21582 }
21583 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21584 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21585 }
21586 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21587 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21588 }
21589 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21590 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21591 }
21592 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21593 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21594 }
21595 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21596 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21597 }
21598 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21599 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21600 }
21601 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21602 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21603 }
21604 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21605 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21606 }
21607 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21608 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21609 }
21610 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21611 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21612 }
21613 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21614 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21615 }
21616 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21617 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21618 }
21619 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21620 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21621 }
21622 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21623 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21624 }
21625 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21626 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21627 }
21628 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21629 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21630 }
21631 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21632 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21633 }
21634 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21635 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21636 }
21637 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21638 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21639 }
21640 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21641 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21642 }
21643 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21644 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21645 }
21646 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21647 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21648 }
21649 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21650 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21651 }
21652 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21653 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21654 }
21655 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21656 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21657 }
21658 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21659 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21660 }
21661 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21662 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21663 }
21664 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21665 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21666 }
21667 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21668 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21669 }
21670 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21671 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21672 }
21673 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21674 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21675 }
21676 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21677 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21678 }
21679 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21680 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21681 }
21682 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21683 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21684 }
21685 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21686 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21687 }
21688 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21689 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21690 }
21691 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21692 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21693 }
21694 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21695 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21696 }
21697 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21698 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21699 }
21700 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21701 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21702 }
21703 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21704 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21705 }
21706 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21707 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21708 }
21709 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21710 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21711 }
21712 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21713 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21714 }
21715 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21716 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21717 }
21718 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21719 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21720 }
21721 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21722 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21723 }
21724 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21725 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21726 }
21727 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21728 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21729 }
21730 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21731 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21732 }
21733 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21734 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21735 }
21736 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21737 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21738 }
21739 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21740 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21741 }
21742 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21743 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21744 }
21745 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21746 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21747 }
21748 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21749 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21750 }
21751 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21752 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21753 }
21754 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21755 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21756 }
21757 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21758 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21759 }
21760 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21761 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21762 }
21763 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21764 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21765 }
21766 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21767 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21768 }
21769 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21770 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21771 }
21772 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21773 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21774 }
21775 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21776 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21777 }
21778 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21779 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21780 }
21781 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21782 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21783 }
21784 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21785 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21786 }
21787 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21788 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21789 }
21790 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21791 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21792 }
21793 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21794 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21795 }
21796 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21797 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21798 }
21799 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21800 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21801 }
21802 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21803 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21804 }
21805 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21806 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21807 }
21808 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21809 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21810 }
21811 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21812 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21813 }
21814 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21815 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21816 }
21817 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21818 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21819 }
21820 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21821 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21822 }
21823 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21824 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21825 }
21826 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21827 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21828 }
21829 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21830 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};
21831 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21832 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21833 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21834 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21835 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21836 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21837 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21838 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21839 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21840 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21841 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21842 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21843 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21844 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21845 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21846 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21847 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21848 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21849 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21850 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21851 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21852 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21853 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21854 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21855 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21856 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21857 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21858 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21859 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21860 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21861 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21862 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21863 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21864 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21865 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21866 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21867 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21868 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21869 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21870 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21871 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21872 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21873 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21874 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21875 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21876 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21877 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21878 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21879 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21880 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21881 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21882 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21883 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21884 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21885 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21886 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21887 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21888 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21889 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21890 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21891 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21892 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21893 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21894 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21895 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21896 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21897 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21898 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21899 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21900 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21901 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21902 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21903 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21904 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21905 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21906 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21907 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21908 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21909 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21910 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21911 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21912 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21913 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21914 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21915 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21916 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21917 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21918 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21919 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21920 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21921 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21922 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21923 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21924 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21925 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21926 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21927 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21928 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21929 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21930 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21931 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21932 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21933 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21934 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21935 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21936 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21937 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21938 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21939 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21940 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21941 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21942 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21943 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21944 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21945 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21946 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21947 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21948 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21949 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21950 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21951 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21952 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21953 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21954 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21955 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21956 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21957 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21958 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21959 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21960 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21961 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21962 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21963 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21964 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21965 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21966 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21967 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21968 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21969 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21970 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21971 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21972 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21973 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21974 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21975 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21976 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21978 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21979 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21980 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21983 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21985 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21986 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21987 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21993 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21994 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21995 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
21996 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
21997 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
21998 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
21999 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22000 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22001 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22002 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22003 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22004 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22005 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22006 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22007 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22008 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22009 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22010 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22011 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22012 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22013 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22014 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22015 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22016
22017 static swig_type_info *swig_type_initial[] = {
22018 &_swigt__p_char,
22019 &_swigt__p_form_ops_t,
22020 &_swigt__p_int,
22021 &_swigt__p_long,
22022 &_swigt__p_unsigned_char,
22023 &_swigt__p_unsigned_int,
22024 &_swigt__p_unsigned_long,
22025 &_swigt__p_wxANIHandler,
22026 &_swigt__p_wxAcceleratorTable,
22027 &_swigt__p_wxActivateEvent,
22028 &_swigt__p_wxArrayString,
22029 &_swigt__p_wxBMPHandler,
22030 &_swigt__p_wxBoxSizer,
22031 &_swigt__p_wxCURHandler,
22032 &_swigt__p_wxCalculateLayoutEvent,
22033 &_swigt__p_wxChildFocusEvent,
22034 &_swigt__p_wxClipboardTextEvent,
22035 &_swigt__p_wxCloseEvent,
22036 &_swigt__p_wxColour,
22037 &_swigt__p_wxColourData,
22038 &_swigt__p_wxColourDialog,
22039 &_swigt__p_wxCommandEvent,
22040 &_swigt__p_wxContextMenuEvent,
22041 &_swigt__p_wxControl,
22042 &_swigt__p_wxControlWithItems,
22043 &_swigt__p_wxDC,
22044 &_swigt__p_wxDateEvent,
22045 &_swigt__p_wxDialog,
22046 &_swigt__p_wxDirDialog,
22047 &_swigt__p_wxDisplayChangedEvent,
22048 &_swigt__p_wxDropFilesEvent,
22049 &_swigt__p_wxDuplexMode,
22050 &_swigt__p_wxEraseEvent,
22051 &_swigt__p_wxEvent,
22052 &_swigt__p_wxEvtHandler,
22053 &_swigt__p_wxFSFile,
22054 &_swigt__p_wxFileDialog,
22055 &_swigt__p_wxFileSystem,
22056 &_swigt__p_wxFindDialogEvent,
22057 &_swigt__p_wxFindReplaceData,
22058 &_swigt__p_wxFindReplaceDialog,
22059 &_swigt__p_wxFlexGridSizer,
22060 &_swigt__p_wxFocusEvent,
22061 &_swigt__p_wxFont,
22062 &_swigt__p_wxFontData,
22063 &_swigt__p_wxFontDialog,
22064 &_swigt__p_wxFrame,
22065 &_swigt__p_wxGBSizerItem,
22066 &_swigt__p_wxGIFHandler,
22067 &_swigt__p_wxGrid,
22068 &_swigt__p_wxGridBagSizer,
22069 &_swigt__p_wxGridCellAttr,
22070 &_swigt__p_wxGridCellAttrProvider,
22071 &_swigt__p_wxGridCellAutoWrapStringEditor,
22072 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22073 &_swigt__p_wxGridCellBoolEditor,
22074 &_swigt__p_wxGridCellBoolRenderer,
22075 &_swigt__p_wxGridCellChoiceEditor,
22076 &_swigt__p_wxGridCellCoords,
22077 &_swigt__p_wxGridCellDateTimeRenderer,
22078 &_swigt__p_wxGridCellEditor,
22079 &_swigt__p_wxGridCellEnumEditor,
22080 &_swigt__p_wxGridCellEnumRenderer,
22081 &_swigt__p_wxGridCellFloatEditor,
22082 &_swigt__p_wxGridCellFloatRenderer,
22083 &_swigt__p_wxGridCellNumberEditor,
22084 &_swigt__p_wxGridCellNumberRenderer,
22085 &_swigt__p_wxGridCellRenderer,
22086 &_swigt__p_wxGridCellStringRenderer,
22087 &_swigt__p_wxGridCellTextEditor,
22088 &_swigt__p_wxGridCellWorker,
22089 &_swigt__p_wxGridEditorCreatedEvent,
22090 &_swigt__p_wxGridEvent,
22091 &_swigt__p_wxGridRangeSelectEvent,
22092 &_swigt__p_wxGridSizeEvent,
22093 &_swigt__p_wxGridSizer,
22094 &_swigt__p_wxGridStringTable,
22095 &_swigt__p_wxGridTableBase,
22096 &_swigt__p_wxGridTableMessage,
22097 &_swigt__p_wxICOHandler,
22098 &_swigt__p_wxIconizeEvent,
22099 &_swigt__p_wxIdleEvent,
22100 &_swigt__p_wxImage,
22101 &_swigt__p_wxImageHandler,
22102 &_swigt__p_wxIndividualLayoutConstraint,
22103 &_swigt__p_wxInitDialogEvent,
22104 &_swigt__p_wxJPEGHandler,
22105 &_swigt__p_wxKeyEvent,
22106 &_swigt__p_wxLayoutAlgorithm,
22107 &_swigt__p_wxLayoutConstraints,
22108 &_swigt__p_wxMDIChildFrame,
22109 &_swigt__p_wxMDIClientWindow,
22110 &_swigt__p_wxMDIParentFrame,
22111 &_swigt__p_wxMaximizeEvent,
22112 &_swigt__p_wxMenu,
22113 &_swigt__p_wxMenuBar,
22114 &_swigt__p_wxMenuEvent,
22115 &_swigt__p_wxMenuItem,
22116 &_swigt__p_wxMessageDialog,
22117 &_swigt__p_wxMiniFrame,
22118 &_swigt__p_wxMouseCaptureChangedEvent,
22119 &_swigt__p_wxMouseEvent,
22120 &_swigt__p_wxMoveEvent,
22121 &_swigt__p_wxMultiChoiceDialog,
22122 &_swigt__p_wxNavigationKeyEvent,
22123 &_swigt__p_wxNcPaintEvent,
22124 &_swigt__p_wxNotifyEvent,
22125 &_swigt__p_wxObject,
22126 &_swigt__p_wxPCXHandler,
22127 &_swigt__p_wxPNGHandler,
22128 &_swigt__p_wxPNMHandler,
22129 &_swigt__p_wxPageSetupDialog,
22130 &_swigt__p_wxPageSetupDialogData,
22131 &_swigt__p_wxPaintEvent,
22132 &_swigt__p_wxPaletteChangedEvent,
22133 &_swigt__p_wxPanel,
22134 &_swigt__p_wxPaperSize,
22135 &_swigt__p_wxPasswordEntryDialog,
22136 &_swigt__p_wxPoint,
22137 &_swigt__p_wxPopupWindow,
22138 &_swigt__p_wxPreviewCanvas,
22139 &_swigt__p_wxPreviewControlBar,
22140 &_swigt__p_wxPreviewFrame,
22141 &_swigt__p_wxPrintData,
22142 &_swigt__p_wxPrintDialog,
22143 &_swigt__p_wxPrintDialogData,
22144 &_swigt__p_wxPrintPreview,
22145 &_swigt__p_wxPrinter,
22146 &_swigt__p_wxProgressDialog,
22147 &_swigt__p_wxPyApp,
22148 &_swigt__p_wxPyCommandEvent,
22149 &_swigt__p_wxPyEvent,
22150 &_swigt__p_wxPyGridCellAttrProvider,
22151 &_swigt__p_wxPyGridCellEditor,
22152 &_swigt__p_wxPyGridCellRenderer,
22153 &_swigt__p_wxPyGridTableBase,
22154 &_swigt__p_wxPyHtmlListBox,
22155 &_swigt__p_wxPyImageHandler,
22156 &_swigt__p_wxPyPanel,
22157 &_swigt__p_wxPyPopupTransientWindow,
22158 &_swigt__p_wxPyPreviewControlBar,
22159 &_swigt__p_wxPyPreviewFrame,
22160 &_swigt__p_wxPyPrintPreview,
22161 &_swigt__p_wxPyPrintout,
22162 &_swigt__p_wxPyScrolledWindow,
22163 &_swigt__p_wxPySizer,
22164 &_swigt__p_wxPyTaskBarIcon,
22165 &_swigt__p_wxPyVListBox,
22166 &_swigt__p_wxPyVScrolledWindow,
22167 &_swigt__p_wxPyValidator,
22168 &_swigt__p_wxPyWindow,
22169 &_swigt__p_wxQueryLayoutInfoEvent,
22170 &_swigt__p_wxQueryNewPaletteEvent,
22171 &_swigt__p_wxRect,
22172 &_swigt__p_wxSashEvent,
22173 &_swigt__p_wxSashLayoutWindow,
22174 &_swigt__p_wxSashWindow,
22175 &_swigt__p_wxScrollEvent,
22176 &_swigt__p_wxScrollWinEvent,
22177 &_swigt__p_wxScrolledWindow,
22178 &_swigt__p_wxSetCursorEvent,
22179 &_swigt__p_wxShowEvent,
22180 &_swigt__p_wxSingleChoiceDialog,
22181 &_swigt__p_wxSizeEvent,
22182 &_swigt__p_wxSizer,
22183 &_swigt__p_wxSizerItem,
22184 &_swigt__p_wxSplashScreen,
22185 &_swigt__p_wxSplashScreenWindow,
22186 &_swigt__p_wxSplitterEvent,
22187 &_swigt__p_wxSplitterWindow,
22188 &_swigt__p_wxStaticBoxSizer,
22189 &_swigt__p_wxStatusBar,
22190 &_swigt__p_wxStdDialogButtonSizer,
22191 &_swigt__p_wxString,
22192 &_swigt__p_wxSysColourChangedEvent,
22193 &_swigt__p_wxTIFFHandler,
22194 &_swigt__p_wxTaskBarIconEvent,
22195 &_swigt__p_wxTextEntryDialog,
22196 &_swigt__p_wxTipWindow,
22197 &_swigt__p_wxTopLevelWindow,
22198 &_swigt__p_wxUpdateUIEvent,
22199 &_swigt__p_wxValidator,
22200 &_swigt__p_wxVisualAttributes,
22201 &_swigt__p_wxWindow,
22202 &_swigt__p_wxWindowCreateEvent,
22203 &_swigt__p_wxWindowDestroyEvent,
22204 &_swigt__p_wxXPMHandler,
22205 };
22206
22207 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22208 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22209 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22210 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22211 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22212 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22213 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22214 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22215 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22216 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22217 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22218 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22219 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22220 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22221 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22222 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22223 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22224 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22225 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22226 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22227 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22228 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_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}};
22229 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22230 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}};
22231 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22232 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22233 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22234 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22235 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22236 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22237 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22238 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22239 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22240 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22241 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22242 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22243 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22244 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22245 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22246 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22247 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22248 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22249 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22250 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22251 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22252 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22253 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22254 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22255 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22256 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22257 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22258 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22259 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22260 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22261 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_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}};
22262 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22263 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22264 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22265 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22266 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22267 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22268 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22269 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22270 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22271 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22272 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22273 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22274 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22275 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22276 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22277 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22278 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22279 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22280 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22281 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22282 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22283 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22284 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22285 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22286 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22287 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22288 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22289 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22290 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22291 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22292 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22293 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22294 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22295 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22296 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22297 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22298 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22299 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22300 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22301 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22302 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22303 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22304 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22305 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22306 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}};
22307 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22308 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22309 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22310 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}};
22311 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22312 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22313 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22314 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22315 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}};
22316 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22317 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22318 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}};
22319 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22320 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22321 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22322 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22323 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22324 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22325 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}};
22326 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}};
22327 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}};
22328 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}};
22329 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22330 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22331 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22332 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22333 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22334 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}};
22335 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22336 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22337 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}};
22338 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22339 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22340 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22341 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22342 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22343 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22344 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22345 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22346 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22351 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22352 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22354 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22355 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22356 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22357 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22358 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22359 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22365 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22366 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22367 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22368 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22375 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22376 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22379 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22380 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22381 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_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_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_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_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_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_wxANIHandler, _p_wxANIHandlerTo_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}};
22382 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}};
22383 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22384 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22385 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22386 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22387 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22388 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22389 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22390 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}};
22391 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22393 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}};
22394
22395 static swig_cast_info *swig_cast_initial[] = {
22396 _swigc__p_char,
22397 _swigc__p_form_ops_t,
22398 _swigc__p_int,
22399 _swigc__p_long,
22400 _swigc__p_unsigned_char,
22401 _swigc__p_unsigned_int,
22402 _swigc__p_unsigned_long,
22403 _swigc__p_wxANIHandler,
22404 _swigc__p_wxAcceleratorTable,
22405 _swigc__p_wxActivateEvent,
22406 _swigc__p_wxArrayString,
22407 _swigc__p_wxBMPHandler,
22408 _swigc__p_wxBoxSizer,
22409 _swigc__p_wxCURHandler,
22410 _swigc__p_wxCalculateLayoutEvent,
22411 _swigc__p_wxChildFocusEvent,
22412 _swigc__p_wxClipboardTextEvent,
22413 _swigc__p_wxCloseEvent,
22414 _swigc__p_wxColour,
22415 _swigc__p_wxColourData,
22416 _swigc__p_wxColourDialog,
22417 _swigc__p_wxCommandEvent,
22418 _swigc__p_wxContextMenuEvent,
22419 _swigc__p_wxControl,
22420 _swigc__p_wxControlWithItems,
22421 _swigc__p_wxDC,
22422 _swigc__p_wxDateEvent,
22423 _swigc__p_wxDialog,
22424 _swigc__p_wxDirDialog,
22425 _swigc__p_wxDisplayChangedEvent,
22426 _swigc__p_wxDropFilesEvent,
22427 _swigc__p_wxDuplexMode,
22428 _swigc__p_wxEraseEvent,
22429 _swigc__p_wxEvent,
22430 _swigc__p_wxEvtHandler,
22431 _swigc__p_wxFSFile,
22432 _swigc__p_wxFileDialog,
22433 _swigc__p_wxFileSystem,
22434 _swigc__p_wxFindDialogEvent,
22435 _swigc__p_wxFindReplaceData,
22436 _swigc__p_wxFindReplaceDialog,
22437 _swigc__p_wxFlexGridSizer,
22438 _swigc__p_wxFocusEvent,
22439 _swigc__p_wxFont,
22440 _swigc__p_wxFontData,
22441 _swigc__p_wxFontDialog,
22442 _swigc__p_wxFrame,
22443 _swigc__p_wxGBSizerItem,
22444 _swigc__p_wxGIFHandler,
22445 _swigc__p_wxGrid,
22446 _swigc__p_wxGridBagSizer,
22447 _swigc__p_wxGridCellAttr,
22448 _swigc__p_wxGridCellAttrProvider,
22449 _swigc__p_wxGridCellAutoWrapStringEditor,
22450 _swigc__p_wxGridCellAutoWrapStringRenderer,
22451 _swigc__p_wxGridCellBoolEditor,
22452 _swigc__p_wxGridCellBoolRenderer,
22453 _swigc__p_wxGridCellChoiceEditor,
22454 _swigc__p_wxGridCellCoords,
22455 _swigc__p_wxGridCellDateTimeRenderer,
22456 _swigc__p_wxGridCellEditor,
22457 _swigc__p_wxGridCellEnumEditor,
22458 _swigc__p_wxGridCellEnumRenderer,
22459 _swigc__p_wxGridCellFloatEditor,
22460 _swigc__p_wxGridCellFloatRenderer,
22461 _swigc__p_wxGridCellNumberEditor,
22462 _swigc__p_wxGridCellNumberRenderer,
22463 _swigc__p_wxGridCellRenderer,
22464 _swigc__p_wxGridCellStringRenderer,
22465 _swigc__p_wxGridCellTextEditor,
22466 _swigc__p_wxGridCellWorker,
22467 _swigc__p_wxGridEditorCreatedEvent,
22468 _swigc__p_wxGridEvent,
22469 _swigc__p_wxGridRangeSelectEvent,
22470 _swigc__p_wxGridSizeEvent,
22471 _swigc__p_wxGridSizer,
22472 _swigc__p_wxGridStringTable,
22473 _swigc__p_wxGridTableBase,
22474 _swigc__p_wxGridTableMessage,
22475 _swigc__p_wxICOHandler,
22476 _swigc__p_wxIconizeEvent,
22477 _swigc__p_wxIdleEvent,
22478 _swigc__p_wxImage,
22479 _swigc__p_wxImageHandler,
22480 _swigc__p_wxIndividualLayoutConstraint,
22481 _swigc__p_wxInitDialogEvent,
22482 _swigc__p_wxJPEGHandler,
22483 _swigc__p_wxKeyEvent,
22484 _swigc__p_wxLayoutAlgorithm,
22485 _swigc__p_wxLayoutConstraints,
22486 _swigc__p_wxMDIChildFrame,
22487 _swigc__p_wxMDIClientWindow,
22488 _swigc__p_wxMDIParentFrame,
22489 _swigc__p_wxMaximizeEvent,
22490 _swigc__p_wxMenu,
22491 _swigc__p_wxMenuBar,
22492 _swigc__p_wxMenuEvent,
22493 _swigc__p_wxMenuItem,
22494 _swigc__p_wxMessageDialog,
22495 _swigc__p_wxMiniFrame,
22496 _swigc__p_wxMouseCaptureChangedEvent,
22497 _swigc__p_wxMouseEvent,
22498 _swigc__p_wxMoveEvent,
22499 _swigc__p_wxMultiChoiceDialog,
22500 _swigc__p_wxNavigationKeyEvent,
22501 _swigc__p_wxNcPaintEvent,
22502 _swigc__p_wxNotifyEvent,
22503 _swigc__p_wxObject,
22504 _swigc__p_wxPCXHandler,
22505 _swigc__p_wxPNGHandler,
22506 _swigc__p_wxPNMHandler,
22507 _swigc__p_wxPageSetupDialog,
22508 _swigc__p_wxPageSetupDialogData,
22509 _swigc__p_wxPaintEvent,
22510 _swigc__p_wxPaletteChangedEvent,
22511 _swigc__p_wxPanel,
22512 _swigc__p_wxPaperSize,
22513 _swigc__p_wxPasswordEntryDialog,
22514 _swigc__p_wxPoint,
22515 _swigc__p_wxPopupWindow,
22516 _swigc__p_wxPreviewCanvas,
22517 _swigc__p_wxPreviewControlBar,
22518 _swigc__p_wxPreviewFrame,
22519 _swigc__p_wxPrintData,
22520 _swigc__p_wxPrintDialog,
22521 _swigc__p_wxPrintDialogData,
22522 _swigc__p_wxPrintPreview,
22523 _swigc__p_wxPrinter,
22524 _swigc__p_wxProgressDialog,
22525 _swigc__p_wxPyApp,
22526 _swigc__p_wxPyCommandEvent,
22527 _swigc__p_wxPyEvent,
22528 _swigc__p_wxPyGridCellAttrProvider,
22529 _swigc__p_wxPyGridCellEditor,
22530 _swigc__p_wxPyGridCellRenderer,
22531 _swigc__p_wxPyGridTableBase,
22532 _swigc__p_wxPyHtmlListBox,
22533 _swigc__p_wxPyImageHandler,
22534 _swigc__p_wxPyPanel,
22535 _swigc__p_wxPyPopupTransientWindow,
22536 _swigc__p_wxPyPreviewControlBar,
22537 _swigc__p_wxPyPreviewFrame,
22538 _swigc__p_wxPyPrintPreview,
22539 _swigc__p_wxPyPrintout,
22540 _swigc__p_wxPyScrolledWindow,
22541 _swigc__p_wxPySizer,
22542 _swigc__p_wxPyTaskBarIcon,
22543 _swigc__p_wxPyVListBox,
22544 _swigc__p_wxPyVScrolledWindow,
22545 _swigc__p_wxPyValidator,
22546 _swigc__p_wxPyWindow,
22547 _swigc__p_wxQueryLayoutInfoEvent,
22548 _swigc__p_wxQueryNewPaletteEvent,
22549 _swigc__p_wxRect,
22550 _swigc__p_wxSashEvent,
22551 _swigc__p_wxSashLayoutWindow,
22552 _swigc__p_wxSashWindow,
22553 _swigc__p_wxScrollEvent,
22554 _swigc__p_wxScrollWinEvent,
22555 _swigc__p_wxScrolledWindow,
22556 _swigc__p_wxSetCursorEvent,
22557 _swigc__p_wxShowEvent,
22558 _swigc__p_wxSingleChoiceDialog,
22559 _swigc__p_wxSizeEvent,
22560 _swigc__p_wxSizer,
22561 _swigc__p_wxSizerItem,
22562 _swigc__p_wxSplashScreen,
22563 _swigc__p_wxSplashScreenWindow,
22564 _swigc__p_wxSplitterEvent,
22565 _swigc__p_wxSplitterWindow,
22566 _swigc__p_wxStaticBoxSizer,
22567 _swigc__p_wxStatusBar,
22568 _swigc__p_wxStdDialogButtonSizer,
22569 _swigc__p_wxString,
22570 _swigc__p_wxSysColourChangedEvent,
22571 _swigc__p_wxTIFFHandler,
22572 _swigc__p_wxTaskBarIconEvent,
22573 _swigc__p_wxTextEntryDialog,
22574 _swigc__p_wxTipWindow,
22575 _swigc__p_wxTopLevelWindow,
22576 _swigc__p_wxUpdateUIEvent,
22577 _swigc__p_wxValidator,
22578 _swigc__p_wxVisualAttributes,
22579 _swigc__p_wxWindow,
22580 _swigc__p_wxWindowCreateEvent,
22581 _swigc__p_wxWindowDestroyEvent,
22582 _swigc__p_wxXPMHandler,
22583 };
22584
22585
22586 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22587
22588 static swig_const_info swig_const_table[] = {
22589 {0, 0, 0, 0.0, 0, 0}};
22590
22591 #ifdef __cplusplus
22592 }
22593 #endif
22594 /* -----------------------------------------------------------------------------
22595 * Type initialization:
22596 * This problem is tough by the requirement that no dynamic
22597 * memory is used. Also, since swig_type_info structures store pointers to
22598 * swig_cast_info structures and swig_cast_info structures store pointers back
22599 * to swig_type_info structures, we need some lookup code at initialization.
22600 * The idea is that swig generates all the structures that are needed.
22601 * The runtime then collects these partially filled structures.
22602 * The SWIG_InitializeModule function takes these initial arrays out of
22603 * swig_module, and does all the lookup, filling in the swig_module.types
22604 * array with the correct data and linking the correct swig_cast_info
22605 * structures together.
22606 *
22607 * The generated swig_type_info structures are assigned staticly to an initial
22608 * array. We just loop though that array, and handle each type individually.
22609 * First we lookup if this type has been already loaded, and if so, use the
22610 * loaded structure instead of the generated one. Then we have to fill in the
22611 * cast linked list. The cast data is initially stored in something like a
22612 * two-dimensional array. Each row corresponds to a type (there are the same
22613 * number of rows as there are in the swig_type_initial array). Each entry in
22614 * a column is one of the swig_cast_info structures for that type.
22615 * The cast_initial array is actually an array of arrays, because each row has
22616 * a variable number of columns. So to actually build the cast linked list,
22617 * we find the array of casts associated with the type, and loop through it
22618 * adding the casts to the list. The one last trick we need to do is making
22619 * sure the type pointer in the swig_cast_info struct is correct.
22620 *
22621 * First off, we lookup the cast->type name to see if it is already loaded.
22622 * There are three cases to handle:
22623 * 1) If the cast->type has already been loaded AND the type we are adding
22624 * casting info to has not been loaded (it is in this module), THEN we
22625 * replace the cast->type pointer with the type pointer that has already
22626 * been loaded.
22627 * 2) If BOTH types (the one we are adding casting info to, and the
22628 * cast->type) are loaded, THEN the cast info has already been loaded by
22629 * the previous module so we just ignore it.
22630 * 3) Finally, if cast->type has not already been loaded, then we add that
22631 * swig_cast_info to the linked list (because the cast->type) pointer will
22632 * be correct.
22633 * ----------------------------------------------------------------------------- */
22634
22635 #ifdef __cplusplus
22636 extern "C" {
22637 #if 0
22638 } /* c-mode */
22639 #endif
22640 #endif
22641
22642 #if 0
22643 #define SWIGRUNTIME_DEBUG
22644 #endif
22645
22646 SWIGRUNTIME void
22647 SWIG_InitializeModule(void *clientdata) {
22648 size_t i;
22649 swig_module_info *module_head;
22650 static int init_run = 0;
22651
22652 clientdata = clientdata;
22653
22654 if (init_run) return;
22655 init_run = 1;
22656
22657 /* Initialize the swig_module */
22658 swig_module.type_initial = swig_type_initial;
22659 swig_module.cast_initial = swig_cast_initial;
22660
22661 /* Try and load any already created modules */
22662 module_head = SWIG_GetModule(clientdata);
22663 if (module_head) {
22664 swig_module.next = module_head->next;
22665 module_head->next = &swig_module;
22666 } else {
22667 /* This is the first module loaded */
22668 swig_module.next = &swig_module;
22669 SWIG_SetModule(clientdata, &swig_module);
22670 }
22671
22672 /* Now work on filling in swig_module.types */
22673 #ifdef SWIGRUNTIME_DEBUG
22674 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22675 #endif
22676 for (i = 0; i < swig_module.size; ++i) {
22677 swig_type_info *type = 0;
22678 swig_type_info *ret;
22679 swig_cast_info *cast;
22680
22681 #ifdef SWIGRUNTIME_DEBUG
22682 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22683 #endif
22684
22685 /* if there is another module already loaded */
22686 if (swig_module.next != &swig_module) {
22687 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22688 }
22689 if (type) {
22690 /* Overwrite clientdata field */
22691 #ifdef SWIGRUNTIME_DEBUG
22692 printf("SWIG_InitializeModule: found type %s\n", type->name);
22693 #endif
22694 if (swig_module.type_initial[i]->clientdata) {
22695 type->clientdata = swig_module.type_initial[i]->clientdata;
22696 #ifdef SWIGRUNTIME_DEBUG
22697 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22698 #endif
22699 }
22700 } else {
22701 type = swig_module.type_initial[i];
22702 }
22703
22704 /* Insert casting types */
22705 cast = swig_module.cast_initial[i];
22706 while (cast->type) {
22707 /* Don't need to add information already in the list */
22708 ret = 0;
22709 #ifdef SWIGRUNTIME_DEBUG
22710 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22711 #endif
22712 if (swig_module.next != &swig_module) {
22713 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22714 #ifdef SWIGRUNTIME_DEBUG
22715 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22716 #endif
22717 }
22718 if (ret) {
22719 if (type == swig_module.type_initial[i]) {
22720 #ifdef SWIGRUNTIME_DEBUG
22721 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22722 #endif
22723 cast->type = ret;
22724 ret = 0;
22725 } else {
22726 /* Check for casting already in the list */
22727 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22728 #ifdef SWIGRUNTIME_DEBUG
22729 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22730 #endif
22731 if (!ocast) ret = 0;
22732 }
22733 }
22734
22735 if (!ret) {
22736 #ifdef SWIGRUNTIME_DEBUG
22737 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22738 #endif
22739 if (type->cast) {
22740 type->cast->prev = cast;
22741 cast->next = type->cast;
22742 }
22743 type->cast = cast;
22744 }
22745 cast++;
22746 }
22747 /* Set entry in modules->types array equal to the type */
22748 swig_module.types[i] = type;
22749 }
22750 swig_module.types[i] = 0;
22751
22752 #ifdef SWIGRUNTIME_DEBUG
22753 printf("**** SWIG_InitializeModule: Cast List ******\n");
22754 for (i = 0; i < swig_module.size; ++i) {
22755 int j = 0;
22756 swig_cast_info *cast = swig_module.cast_initial[i];
22757 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22758 while (cast->type) {
22759 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22760 cast++;
22761 ++j;
22762 }
22763 printf("---- Total casts: %d\n",j);
22764 }
22765 printf("**** SWIG_InitializeModule: Cast List ******\n");
22766 #endif
22767 }
22768
22769 /* This function will propagate the clientdata field of type to
22770 * any new swig_type_info structures that have been added into the list
22771 * of equivalent types. It is like calling
22772 * SWIG_TypeClientData(type, clientdata) a second time.
22773 */
22774 SWIGRUNTIME void
22775 SWIG_PropagateClientData(void) {
22776 size_t i;
22777 swig_cast_info *equiv;
22778 static int init_run = 0;
22779
22780 if (init_run) return;
22781 init_run = 1;
22782
22783 for (i = 0; i < swig_module.size; i++) {
22784 if (swig_module.types[i]->clientdata) {
22785 equiv = swig_module.types[i]->cast;
22786 while (equiv) {
22787 if (!equiv->converter) {
22788 if (equiv->type && !equiv->type->clientdata)
22789 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22790 }
22791 equiv = equiv->next;
22792 }
22793 }
22794 }
22795 }
22796
22797 #ifdef __cplusplus
22798 #if 0
22799 {
22800 /* c-mode */
22801 #endif
22802 }
22803 #endif
22804
22805
22806
22807 #ifdef __cplusplus
22808 extern "C" {
22809 #endif
22810
22811 /* Python-specific SWIG API */
22812 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22813 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22814 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22815
22816 /* -----------------------------------------------------------------------------
22817 * global variable support code.
22818 * ----------------------------------------------------------------------------- */
22819
22820 typedef struct swig_globalvar {
22821 char *name; /* Name of global variable */
22822 PyObject *(*get_attr)(void); /* Return the current value */
22823 int (*set_attr)(PyObject *); /* Set the value */
22824 struct swig_globalvar *next;
22825 } swig_globalvar;
22826
22827 typedef struct swig_varlinkobject {
22828 PyObject_HEAD
22829 swig_globalvar *vars;
22830 } swig_varlinkobject;
22831
22832 SWIGINTERN PyObject *
22833 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22834 return PyString_FromString("<Swig global variables>");
22835 }
22836
22837 SWIGINTERN PyObject *
22838 swig_varlink_str(swig_varlinkobject *v) {
22839 PyObject *str = PyString_FromString("(");
22840 swig_globalvar *var;
22841 for (var = v->vars; var; var=var->next) {
22842 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22843 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22844 }
22845 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22846 return str;
22847 }
22848
22849 SWIGINTERN int
22850 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22851 PyObject *str = swig_varlink_str(v);
22852 fprintf(fp,"Swig global variables ");
22853 fprintf(fp,"%s\n", PyString_AsString(str));
22854 Py_DECREF(str);
22855 return 0;
22856 }
22857
22858 SWIGINTERN void
22859 swig_varlink_dealloc(swig_varlinkobject *v) {
22860 swig_globalvar *var = v->vars;
22861 while (var) {
22862 swig_globalvar *n = var->next;
22863 free(var->name);
22864 free(var);
22865 var = n;
22866 }
22867 }
22868
22869 SWIGINTERN PyObject *
22870 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22871 PyObject *res = NULL;
22872 swig_globalvar *var = v->vars;
22873 while (var) {
22874 if (strcmp(var->name,n) == 0) {
22875 res = (*var->get_attr)();
22876 break;
22877 }
22878 var = var->next;
22879 }
22880 if (res == NULL && !PyErr_Occurred()) {
22881 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22882 }
22883 return res;
22884 }
22885
22886 SWIGINTERN int
22887 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22888 int res = 1;
22889 swig_globalvar *var = v->vars;
22890 while (var) {
22891 if (strcmp(var->name,n) == 0) {
22892 res = (*var->set_attr)(p);
22893 break;
22894 }
22895 var = var->next;
22896 }
22897 if (res == 1 && !PyErr_Occurred()) {
22898 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22899 }
22900 return res;
22901 }
22902
22903 SWIGINTERN PyTypeObject*
22904 swig_varlink_type(void) {
22905 static char varlink__doc__[] = "Swig var link object";
22906 static PyTypeObject varlink_type;
22907 static int type_init = 0;
22908 if (!type_init) {
22909 const PyTypeObject tmp
22910 = {
22911 PyObject_HEAD_INIT(NULL)
22912 0, /* Number of items in variable part (ob_size) */
22913 (char *)"swigvarlink", /* Type name (tp_name) */
22914 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22915 0, /* Itemsize (tp_itemsize) */
22916 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22917 (printfunc) swig_varlink_print, /* Print (tp_print) */
22918 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22919 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22920 0, /* tp_compare */
22921 (reprfunc) swig_varlink_repr, /* tp_repr */
22922 0, /* tp_as_number */
22923 0, /* tp_as_sequence */
22924 0, /* tp_as_mapping */
22925 0, /* tp_hash */
22926 0, /* tp_call */
22927 (reprfunc)swig_varlink_str, /* tp_str */
22928 0, /* tp_getattro */
22929 0, /* tp_setattro */
22930 0, /* tp_as_buffer */
22931 0, /* tp_flags */
22932 varlink__doc__, /* tp_doc */
22933 0, /* tp_traverse */
22934 0, /* tp_clear */
22935 0, /* tp_richcompare */
22936 0, /* tp_weaklistoffset */
22937 #if PY_VERSION_HEX >= 0x02020000
22938 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22939 #endif
22940 #if PY_VERSION_HEX >= 0x02030000
22941 0, /* tp_del */
22942 #endif
22943 #ifdef COUNT_ALLOCS
22944 0,0,0,0 /* tp_alloc -> tp_next */
22945 #endif
22946 };
22947 varlink_type = tmp;
22948 varlink_type.ob_type = &PyType_Type;
22949 type_init = 1;
22950 }
22951 return &varlink_type;
22952 }
22953
22954 /* Create a variable linking object for use later */
22955 SWIGINTERN PyObject *
22956 SWIG_Python_newvarlink(void) {
22957 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22958 if (result) {
22959 result->vars = 0;
22960 }
22961 return ((PyObject*) result);
22962 }
22963
22964 SWIGINTERN void
22965 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22966 swig_varlinkobject *v = (swig_varlinkobject *) p;
22967 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22968 if (gv) {
22969 size_t size = strlen(name)+1;
22970 gv->name = (char *)malloc(size);
22971 if (gv->name) {
22972 strncpy(gv->name,name,size);
22973 gv->get_attr = get_attr;
22974 gv->set_attr = set_attr;
22975 gv->next = v->vars;
22976 }
22977 }
22978 v->vars = gv;
22979 }
22980
22981 SWIGINTERN PyObject *
22982 SWIG_globals() {
22983 static PyObject *_SWIG_globals = 0;
22984 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22985 return _SWIG_globals;
22986 }
22987
22988 /* -----------------------------------------------------------------------------
22989 * constants/methods manipulation
22990 * ----------------------------------------------------------------------------- */
22991
22992 /* Install Constants */
22993 SWIGINTERN void
22994 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22995 PyObject *obj = 0;
22996 size_t i;
22997 for (i = 0; constants[i].type; ++i) {
22998 switch(constants[i].type) {
22999 case SWIG_PY_POINTER:
23000 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23001 break;
23002 case SWIG_PY_BINARY:
23003 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23004 break;
23005 default:
23006 obj = 0;
23007 break;
23008 }
23009 if (obj) {
23010 PyDict_SetItemString(d, constants[i].name, obj);
23011 Py_DECREF(obj);
23012 }
23013 }
23014 }
23015
23016 /* -----------------------------------------------------------------------------*/
23017 /* Fix SwigMethods to carry the callback ptrs when needed */
23018 /* -----------------------------------------------------------------------------*/
23019
23020 SWIGINTERN void
23021 SWIG_Python_FixMethods(PyMethodDef *methods,
23022 swig_const_info *const_table,
23023 swig_type_info **types,
23024 swig_type_info **types_initial) {
23025 size_t i;
23026 for (i = 0; methods[i].ml_name; ++i) {
23027 const char *c = methods[i].ml_doc;
23028 if (c && (c = strstr(c, "swig_ptr: "))) {
23029 int j;
23030 swig_const_info *ci = 0;
23031 const char *name = c + 10;
23032 for (j = 0; const_table[j].type; ++j) {
23033 if (strncmp(const_table[j].name, name,
23034 strlen(const_table[j].name)) == 0) {
23035 ci = &(const_table[j]);
23036 break;
23037 }
23038 }
23039 if (ci) {
23040 size_t shift = (ci->ptype) - types;
23041 swig_type_info *ty = types_initial[shift];
23042 size_t ldoc = (c - methods[i].ml_doc);
23043 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23044 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23045 if (ndoc) {
23046 char *buff = ndoc;
23047 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23048 if (ptr) {
23049 strncpy(buff, methods[i].ml_doc, ldoc);
23050 buff += ldoc;
23051 strncpy(buff, "swig_ptr: ", 10);
23052 buff += 10;
23053 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23054 methods[i].ml_doc = ndoc;
23055 }
23056 }
23057 }
23058 }
23059 }
23060 }
23061
23062 #ifdef __cplusplus
23063 }
23064 #endif
23065
23066 /* -----------------------------------------------------------------------------*
23067 * Partial Init method
23068 * -----------------------------------------------------------------------------*/
23069
23070 #ifdef __cplusplus
23071 extern "C"
23072 #endif
23073 SWIGEXPORT void SWIG_init(void) {
23074 PyObject *m, *d;
23075
23076 /* Fix SwigMethods to carry the callback ptrs when needed */
23077 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23078
23079 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23080 d = PyModule_GetDict(m);
23081
23082 SWIG_InitializeModule(0);
23083 SWIG_InstallConstants(d,swig_const_table);
23084
23085
23086 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23087 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23088 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23089 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23090 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23091 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23092 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23093 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23094 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23095 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23096 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23097 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23098 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23099 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23100 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23101 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23102 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23103 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23104 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23105 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23106 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23107 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23108 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23109 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23110 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23111 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23112 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23113 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23114 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23115 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23116 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23117 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23118 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23119 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23120 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23121 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23122 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23123 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23124 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23125 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23126 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23127 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23128 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23129 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23130 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23131 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23132 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23133 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23134 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23135 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23136 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23137 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23138 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23139 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23140 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23141 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23142
23143
23144 }
23145
wxWidgets (Impactor)